arch/tile/lib/memset_64.c

   1 /*
   2  * Copyright 2011 Tilera Corporation. All Rights Reserved.
   3  *
   4  *   This program is free software; you can redistribute it and/or
   5  *   modify it under the terms of the GNU General Public License
   6  *   as published by the Free Software Foundation, version 2.
   7  *
   8  *   This program is distributed in the hope that it will be useful, but
   9  *   WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  11  *   NON INFRINGEMENT.  See the GNU General Public License for
  12  *   more details.
  13  */
  14
  15 #include <arch/chip.h>
  16
  17 #include <linux/types.h>
  18 #include <linux/string.h>
  19 #include <linux/module.h>
  20
  21 #undef memset
  22
  23 void *memset(void *s, int c, size_t n)
  24 {
  25         uint64_t *out64;
  26         int n64, to_align64;
  27         uint64_t v64;
  28         uint8_t *out8 = s;
  29
  30         /* Experimentation shows that a trivial tight loop is a win up until
  31          * around a size of 20, where writing a word at a time starts to win.
  32          */
  33 #define BYTE_CUTOFF 20
  34
  35 #if BYTE_CUTOFF < 7
  36         /* This must be at least at least this big, or some code later
  37          * on doesn't work.
  38          */
  39 #error "BYTE_CUTOFF is too small"
  40 #endif
  41
  42         if (n < BYTE_CUTOFF) {
  43                 /* Strangely, this turns out to be the tightest way to
  44                  * write this loop.
  45                  */
  46                 if (n != 0) {
  47                         do {
  48                                 /* Strangely, combining these into one line
  49                                  * performs worse.
  50                                  */
  51                                 *out8 = c;
  52                                 out8++;
  53                         } while (--n != 0);
  54                 }
  55
  56                 return s;
  57         }
  58
  59         /* Align 'out8'. We know n >= 7 so this won't write past the end. */
  60         while (((uintptr_t) out8 & 7) != 0) {
  61                 *out8++ = c;
  62                 --n;
  63         }
  64
  65         /* Align 'n'. */
  66         while (n & 7)
  67                 out8[--n] = c;
  68
  69         out64 = (uint64_t *) out8;
  70         n64 = n >> 3;
  71
  72         /* Tile input byte out to 64 bits. */
  73         /* KLUDGE */
  74         v64 = 0x0101010101010101ULL * (uint8_t)c;
  75
  76         /* This must be at least 8 or the following loop doesn't work. */
  77 #define CACHE_LINE_SIZE_IN_DOUBLEWORDS (CHIP_L2_LINE_SIZE() / 8)
  78
  79         /* Determine how many words we need to emit before the 'out32'
  80          * pointer becomes aligned modulo the cache line size.
  81          */
  82         to_align64 = (-((uintptr_t)out64 >> 3)) &
  83                 (CACHE_LINE_SIZE_IN_DOUBLEWORDS - 1);
  84
  85         /* Only bother aligning and using wh64 if there is at least
  86          * one full cache line to process.  This check also prevents
  87          * overrunning the end of the buffer with alignment words.
  88          */
  89         if (to_align64 <= n64 - CACHE_LINE_SIZE_IN_DOUBLEWORDS) {
  90                 int lines_left;
  91
  92                 /* Align out64 mod the cache line size so we can use wh64. */
  93                 n64 -= to_align64;
  94                 for (; to_align64 != 0; to_align64--) {
  95                         *out64 = v64;
  96                         out64++;
  97                 }
  98
  99                 /* Use unsigned divide to turn this into a right shift. */
 100                 lines_left = (unsigned)n64 / CACHE_LINE_SIZE_IN_DOUBLEWORDS;
 101
 102                 do {
 103                         /* Only wh64 a few lines at a time, so we don't
 104                          * exceed the maximum number of victim lines.
 105                          */
 106                         int x = ((lines_left < CHIP_MAX_OUTSTANDING_VICTIMS())
 107                                   ? lines_left
 108                                   : CHIP_MAX_OUTSTANDING_VICTIMS());
 109                         uint64_t *wh = out64;
 110                         int i = x;
 111                         int j;
 112
 113                         lines_left -= x;
 114
 115                         do {
 116                                 __insn_wh64(wh);
 117                                 wh += CACHE_LINE_SIZE_IN_DOUBLEWORDS;
 118                         } while (--i);
 119
 120                         for (j = x * (CACHE_LINE_SIZE_IN_DOUBLEWORDS / 4);
 121                              j != 0; j--) {
 122                                 *out64++ = v64;
 123                                 *out64++ = v64;
 124                                 *out64++ = v64;
 125                                 *out64++ = v64;
 126                         }
 127                 } while (lines_left != 0);
 128
 129                 /* We processed all full lines above, so only this many
 130                  * words remain to be processed.
 131                  */
 132                 n64 &= CACHE_LINE_SIZE_IN_DOUBLEWORDS - 1;
 133         }
 134
 135         /* Now handle any leftover values. */
 136         if (n64 != 0) {
 137                 do {
 138                         *out64 = v64;
 139                         out64++;
 140                 } while (--n64 != 0);
 141         }
 142
 143         return s;
 144 }
 145 EXPORT_SYMBOL(memset);