Return to sub_n.c CVS log

Up to [local] / OpenXM_contrib / gmp / mpn / cray

Annotation of OpenXM_contrib/gmp/mpn/cray/sub_n.c, Revision 1.1

1.1     ! maekawa     1: /* mpn_sub_n -- Subtract two limb vectors of equal, non-zero length.
        !             2:    For Cray vector processors.
        !             3:
        !             4:    Copyright (C) 1996, 2000 Free Software Foundation, Inc.
        !             5:
        !             6:    This file is part of the GNU MP Library.
        !             7:
        !             8:    The GNU MP Library is free software; you can redistribute it and/or modify
        !             9:    it under the terms of the GNU Lesser General Public License as published by
        !            10:    the Free Software Foundation; either version 2.1 of the License, or (at your
        !            11:    option) any later version.
        !            12:
        !            13:    The GNU MP Library is distributed in the hope that it will be useful, but
        !            14:    WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
        !            15:    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
        !            16:    License for more details.
        !            17:
        !            18:    You should have received a copy of the GNU Lesser General Public License
        !            19:    along with the GNU MP Library; see the file COPYING.LIB.  If not, write to
        !            20:    the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
        !            21:    MA 02111-1307, USA.  */
        !            22:
        !            23: #include "gmp.h"
        !            24: #include "gmp-impl.h"
        !            25:
        !            26: mp_limb_t
        !            27: mpn_sub_n (c, a, b, n)
        !            28:      mp_ptr c;
        !            29:      mp_srcptr a, b;
        !            30:      mp_size_t n;
        !            31: {
        !            32:   mp_size_t i;
        !            33:   mp_size_t nm1 = n - 1;
        !            34:   int more_carries = 0;
        !            35:   int carry_out;
        !            36:
        !            37:   /* For small operands the non-vector code is faster.  */
        !            38:   if (n < 16)
        !            39:     goto sequential;
        !            40:
        !            41:   if (a == c || b == c)
        !            42:     {
        !            43:       TMP_DECL (marker);
        !            44:       TMP_MARK (marker);
        !            45:       if (c == a)
        !            46:        {
        !            47:          /* allocate temp space for a */
        !            48:          mp_ptr ax = (mp_ptr) TMP_ALLOC (n * BYTES_PER_MP_LIMB);
        !            49:          MPN_COPY (ax, a, n);
        !            50:          a = (mp_srcptr) ax;
        !            51:        }
        !            52:       if (c == b)
        !            53:        {
        !            54:          /* allocate temp space for b */
        !            55:          mp_ptr bx = (mp_ptr) TMP_ALLOC (n * BYTES_PER_MP_LIMB);
        !            56:          MPN_COPY (bx, b, n);
        !            57:          b = (mp_srcptr) bx;
        !            58:        }
        !            59:       carry_out = mpn_sub_n (c, a, b, n);
        !            60:       TMP_FREE (marker);
        !            61:       return carry_out;
        !            62:     }
        !            63:
        !            64:   carry_out = a[nm1] < b[nm1];
        !            65:
        !            66: #pragma _CRI ivdep                     /* Cray PVP systems */
        !            67:   for (i = nm1; i > 0; i--)
        !            68:     {
        !            69:       int cy_in; mp_limb_t t;
        !            70:       cy_in = a[i - 1] < b[i - 1];
        !            71:       t = a[i] - b[i];
        !            72:       more_carries += t < cy_in;
        !            73:       c[i] = t - cy_in;
        !            74:     }
        !            75:   c[0] = a[0] - b[0];
        !            76:
        !            77:   if (more_carries)
        !            78:     {
        !            79:       /* This won't vectorize, but we should come here rarely.  */
        !            80:       int cy;
        !            81:     sequential:
        !            82:       cy = 0;
        !            83:       for (i = 0; i < n; i++)
        !            84:        {
        !            85:          mp_limb_t ai, ci, t;
        !            86:          ai = a[i];
        !            87:          t = b[i] + cy;
        !            88:          cy = t < cy;
        !            89:          ci = ai - t;
        !            90:          cy += ci > ai;
        !            91:          c[i] = ci;
        !            92:        }
        !            93:       carry_out = cy;
        !            94:     }
        !            95:
        !            96:   return carry_out;
        !            97: }