kernel/mips/cswap_msa.c

   1 /*******************************************************************************
   2 Copyright (c) 2016, The OpenBLAS Project
   3 All rights reserved.
   4 Redistribution and use in source and binary forms, with or without
   5 modification, are permitted provided that the following conditions are
   6 met:
   7 1. Redistributions of source code must retain the above copyright
   8 notice, this list of conditions and the following disclaimer.
   9 2. Redistributions in binary form must reproduce the above copyright
  10 notice, this list of conditions and the following disclaimer in
  11 the documentation and/or other materials provided with the
  12 distribution.
  13 3. Neither the name of the OpenBLAS project nor the names of
  14 its contributors may be used to endorse or promote products
  15 derived from this software without specific prior written permission.
  16 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19 ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
  20 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  22 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  23 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  24 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  25 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26 *******************************************************************************/
  27
  28 #include "common.h"
  29 #include "macros_msa.h"
  30
  31 int CNAME(BLASLONG n, BLASLONG dummy0, BLASLONG dummy1, FLOAT dummy3,
  32           FLOAT dummy4, FLOAT *srcx, BLASLONG inc_x, FLOAT *srcy,
  33           BLASLONG inc_y, FLOAT *dummy, BLASLONG dummy2)
  34 {
  35     BLASLONG i = 0, pref_offsetx, pref_offsety;
  36     FLOAT *px, *py;
  37     BLASLONG inc_x2, inc_y2;
  38     FLOAT x0, x1, x2, x3, x4, x5, x6, x7;
  39     FLOAT y0, y1, y2, y3, y4, y5, y6, y7;
  40     v4f32 xv0, xv1, xv2, xv3, xv4, xv5, xv6, xv7;
  41     v4f32 yv0, yv1, yv2, yv3, yv4, yv5, yv6, yv7;
  42
  43     if (n < 0)  return (0);
  44
  45     pref_offsetx = (BLASLONG)srcx & (L1_DATA_LINESIZE - 1);
  46     if (pref_offsetx > 0)
  47     {
  48         pref_offsetx = L1_DATA_LINESIZE - pref_offsetx;
  49         pref_offsetx = pref_offsetx / sizeof(FLOAT);
  50     }
  51
  52     pref_offsety = (BLASLONG)srcy & (L1_DATA_LINESIZE - 1);
  53     if (pref_offsety > 0)
  54     {
  55         pref_offsety = L1_DATA_LINESIZE - pref_offsety;
  56         pref_offsety = pref_offsety / sizeof(FLOAT);
  57     }
  58
  59     px = srcx;
  60     py = srcy;
  61
  62     inc_x2 = 2 * inc_x;
  63     inc_y2 = 2 * inc_y;
  64
  65     if ((1 == inc_x) && (1 == inc_y))
  66     {
  67         if (n >> 4)
  68         {
  69             LD_SP8_INC(px, 4, xv0, xv1, xv2, xv3, xv4, xv5, xv6, xv7);
  70
  71             for (i = (n >> 4) - 1; i--;)
  72             {
  73                 PREFETCH(px + pref_offsetx + 32);
  74                 PREFETCH(px + pref_offsetx + 40);
  75                 PREFETCH(px + pref_offsetx + 48);
  76                 PREFETCH(px + pref_offsetx + 56);
  77
  78                 PREFETCH(py + pref_offsety + 32);
  79                 PREFETCH(py + pref_offsety + 40);
  80                 PREFETCH(py + pref_offsety + 48);
  81                 PREFETCH(py + pref_offsety + 56);
  82
  83                 yv0 = LD_SP(py); py += 4;
  84                 ST_SP(xv0, srcy); srcy += 4;
  85                 yv1 = LD_SP(py); py += 4;
  86                 ST_SP(xv1, srcy); srcy += 4;
  87                 yv2 = LD_SP(py); py += 4;
  88                 ST_SP(xv2, srcy); srcy += 4;
  89                 yv3 = LD_SP(py); py += 4;
  90                 ST_SP(xv3, srcy); srcy += 4;
  91                 yv4 = LD_SP(py); py += 4;
  92                 ST_SP(xv4, srcy); srcy += 4;
  93                 yv5 = LD_SP(py); py += 4;
  94                 ST_SP(xv5, srcy); srcy += 4;
  95                 yv6 = LD_SP(py); py += 4;
  96                 ST_SP(xv6, srcy); srcy += 4;
  97                 yv7 = LD_SP(py); py += 4;
  98                 ST_SP(xv7, srcy); srcy += 4;
  99
 100                 xv0 = LD_SP(px); px += 4;
 101                 ST_SP(yv0, srcx); srcx += 4;
 102                 xv1 = LD_SP(px); px += 4;
 103                 ST_SP(yv1, srcx); srcx += 4;
 104                 xv2 = LD_SP(px); px += 4;
 105                 ST_SP(yv2, srcx); srcx += 4;
 106                 xv3 = LD_SP(px); px += 4;
 107                 ST_SP(yv3, srcx); srcx += 4;
 108                 xv4 = LD_SP(px); px += 4;
 109                 ST_SP(yv4, srcx); srcx += 4;
 110                 xv5 = LD_SP(px); px += 4;
 111                 ST_SP(yv5, srcx); srcx += 4;
 112                 xv6 = LD_SP(px); px += 4;
 113                 ST_SP(yv6, srcx); srcx += 4;
 114                 xv7 = LD_SP(px); px += 4;
 115                 ST_SP(yv7, srcx); srcx += 4;
 116             }
 117
 118             LD_SP8_INC(py, 4, yv0, yv1, yv2, yv3, yv4, yv5, yv6, yv7);
 119             ST_SP8_INC(xv0, xv1, xv2, xv3, xv4, xv5, xv6, xv7, srcy, 4);
 120             ST_SP8_INC(yv0, yv1, yv2, yv3, yv4, yv5, yv6, yv7, srcx, 4);
 121         }
 122
 123         if (n & 15)
 124         {
 125             if ((n & 8) && (n & 4) && (n & 2))
 126             {
 127                 LD_SP7_INC(px, 4, xv0, xv1, xv2, xv3, xv4, xv5, xv6);
 128                 LD_SP7_INC(py, 4, yv0, yv1, yv2, yv3, yv4, yv5, yv6);
 129                 ST_SP7_INC(xv0, xv1, xv2, xv3, xv4, xv5, xv6, srcy, 4);
 130                 ST_SP7_INC(yv0, yv1, yv2, yv3, yv4, yv5, yv6, srcx, 4);
 131             }
 132             else if ((n & 8) && (n & 4))
 133             {
 134                 LD_SP6_INC(px, 4, xv0, xv1, xv2, xv3, xv4, xv5);
 135                 LD_SP6_INC(py, 4, yv0, yv1, yv2, yv3, yv4, yv5);
 136                 ST_SP6_INC(xv0, xv1, xv2, xv3, xv4, xv5, srcy, 4);
 137                 ST_SP6_INC(yv0, yv1, yv2, yv3, yv4, yv5, srcx, 4);
 138             }
 139             else if ((n & 8) && (n & 2))
 140             {
 141                 LD_SP5_INC(px, 4, xv0, xv1, xv2, xv3, xv4);
 142                 LD_SP5_INC(py, 4, yv0, yv1, yv2, yv3, yv4);
 143                 ST_SP5_INC(xv0, xv1, xv2, xv3, xv4, srcy, 4);
 144                 ST_SP5_INC(yv0, yv1, yv2, yv3, yv4, srcx, 4);
 145             }
 146             else if ((n & 4) && (n & 2))
 147             {
 148                 LD_SP3_INC(px, 4, xv0, xv1, xv2);
 149                 LD_SP3_INC(py, 4, yv0, yv1, yv2);
 150                 ST_SP3_INC(xv0, xv1, xv2, srcy, 4);
 151                 ST_SP3_INC(yv0, yv1, yv2, srcx, 4);
 152             }
 153             else if (n & 8)
 154             {
 155                 LD_SP4_INC(px, 4, xv0, xv1, xv2, xv3);
 156                 LD_SP4_INC(py, 4, yv0, yv1, yv2, yv3);
 157                 ST_SP4_INC(xv0, xv1, xv2, xv3, srcy, 4);
 158                 ST_SP4_INC(yv0, yv1, yv2, yv3, srcx, 4);
 159             }
 160             else if (n & 4)
 161             {
 162                 LD_SP2_INC(px, 4, xv0, xv1);
 163                 LD_SP2_INC(py, 4, yv0, yv1);
 164                 ST_SP2_INC(xv0, xv1, srcy, 4);
 165                 ST_SP2_INC(yv0, yv1, srcx, 4);
 166             }
 167             else if (n & 2)
 168             {
 169                 xv0 = LD_SP(px);
 170                 yv0 = LD_SP(py);
 171
 172                 px += 4;
 173                 py += 4;
 174
 175                 ST_SP(xv0, srcy);
 176                 ST_SP(yv0, srcx);
 177
 178                 srcx += 4;
 179                 srcy += 4;
 180             }
 181
 182             if (n & 1)
 183             {
 184                 LD_GP2_INC(px, 1, x0, x1);
 185                 LD_GP2_INC(py, 1, y0, y1);
 186                 ST_GP2_INC(x0, x1, srcy, 1);
 187                 ST_GP2_INC(y0, y1, srcx, 1);
 188             }
 189         }
 190     }
 191     else
 192     {
 193         for (i = (n >> 2); i--;)
 194         {
 195             x0 = srcx[0 * inc_x2];
 196             x1 = srcx[0 * inc_x2 + 1];
 197             x2 = srcx[1 * inc_x2];
 198             x3 = srcx[1 * inc_x2 + 1];
 199             x4 = srcx[2 * inc_x2];
 200             x5 = srcx[2 * inc_x2 + 1];
 201             x6 = srcx[3 * inc_x2];
 202             x7 = srcx[3 * inc_x2 + 1];
 203
 204             y0 = srcy[0 * inc_y2];
 205             y1 = srcy[0 * inc_y2 + 1];
 206             y2 = srcy[1 * inc_y2];
 207             y3 = srcy[1 * inc_y2 + 1];
 208             y4 = srcy[2 * inc_y2];
 209             y5 = srcy[2 * inc_y2 + 1];
 210             y6 = srcy[3 * inc_y2];
 211             y7 = srcy[3 * inc_y2 + 1];
 212
 213             srcx[0 * inc_x2]     = y0;
 214             srcx[0 * inc_x2 + 1] = y1;
 215             srcx[1 * inc_x2]     = y2;
 216             srcx[1 * inc_x2 + 1] = y3;
 217             srcx[2 * inc_x2]     = y4;
 218             srcx[2 * inc_x2 + 1] = y5;
 219             srcx[3 * inc_x2]     = y6;
 220             srcx[3 * inc_x2 + 1] = y7;
 221
 222             srcy[0 * inc_y2]     = x0;
 223             srcy[0 * inc_y2 + 1] = x1;
 224             srcy[1 * inc_y2]     = x2;
 225             srcy[1 * inc_y2 + 1] = x3;
 226             srcy[2 * inc_y2]     = x4;
 227             srcy[2 * inc_y2 + 1] = x5;
 228             srcy[3 * inc_y2]     = x6;
 229             srcy[3 * inc_y2 + 1] = x7;
 230
 231             srcx += 4 * inc_x2;
 232             srcy += 4 * inc_y2;
 233         }
 234
 235         if (n & 2)
 236         {
 237             x0 = srcx[0 * inc_x2];
 238             x1 = srcx[0 * inc_x2 + 1];
 239             x2 = srcx[1 * inc_x2];
 240             x3 = srcx[1 * inc_x2 + 1];
 241
 242             y0 = srcy[0 * inc_y2];
 243             y1 = srcy[0 * inc_y2 + 1];
 244             y2 = srcy[1 * inc_y2];
 245             y3 = srcy[1 * inc_y2 + 1];
 246
 247             srcx[0 * inc_x2]     = y0;
 248             srcx[0 * inc_x2 + 1] = y1;
 249             srcx[1 * inc_x2]     = y2;
 250             srcx[1 * inc_x2 + 1] = y3;
 251
 252             srcy[0 * inc_y2]     = x0;
 253             srcy[0 * inc_y2 + 1] = x1;
 254             srcy[1 * inc_y2]     = x2;
 255             srcy[1 * inc_y2 + 1] = x3;
 256
 257             srcx += 2 * inc_x2;
 258             srcy += 2 * inc_y2;
 259         }
 260
 261         if (n & 1)
 262         {
 263             x0 = srcx[0 * inc_x2];
 264             x1 = srcx[0 * inc_x2 + 1];
 265
 266             y0 = srcy[0 * inc_y2];
 267             y1 = srcy[0 * inc_y2 + 1];
 268
 269             srcx[0 * inc_x2]     = y0;
 270             srcx[0 * inc_x2 + 1] = y1;
 271
 272             srcy[0 * inc_y2]     = x0;
 273             srcy[0 * inc_y2 + 1] = x1;
 274
 275             srcx += inc_x2;
 276             srcy += inc_y2;
 277         }
 278     }
 279
 280     return (0);
 281 }