Line data    Source code

       1             : /*
       2             :  * Copyright (C) 2013 Andrea Mazzoleni
       3             :  *
       4             :  * This program is free software: you can redistribute it and/or modify
       5             :  * it under the terms of the GNU General Public License as published by
       6             :  * the Free Software Foundation, either version 2 of the License, or
       7             :  * (at your option) any later version.
       8             :  *
       9             :  * This program is distributed in the hope that it will be useful,
      10             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      11             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      12             :  * GNU General Public License for more details.
      13             :  */
      14             : 
      15             : #include "internal.h"
      16             : #include "gf.h"
      17             : 
      18             : /*
      19             :  * GENz (triple parity with powers of 2^-1) 32bit C implementation
      20             :  */
      21          29 : void raid_genz_int32(int nd, size_t size, void **vv)
      22             : {
      23          29 :         uint8_t **v = (uint8_t**)vv;
      24             :         uint8_t *p;
      25             :         uint8_t *q;
      26             :         uint8_t *r;
      27             :         int d, l;
      28             :         size_t i;
      29             : 
      30             :         uint32_t d0, r0, q0, p0;
      31             :         uint32_t d1, r1, q1, p1;
      32             : 
      33          29 :         l = nd - 1;
      34          29 :         p = v[nd];
      35          29 :         q = v[nd + 1];
      36          29 :         r = v[nd + 2];
      37             : 
      38      917565 :         for (i = 0; i < size; i += 8) {
      39      917536 :                 r0 = q0 = p0 = v_32(v[l][i]);
      40      917536 :                 r1 = q1 = p1 = v_32(v[l][i + 4]);
      41     7341056 :                 for (d = l - 1; d >= 0; --d) {
      42     6423520 :                         d0 = v_32(v[d][i]);
      43     6423520 :                         d1 = v_32(v[d][i + 4]);
      44             : 
      45     6423520 :                         p0 ^= d0;
      46     6423520 :                         p1 ^= d1;
      47             : 
      48     6423520 :                         q0 = x2_32(q0);
      49     6423520 :                         q1 = x2_32(q1);
      50             : 
      51     6423520 :                         q0 ^= d0;
      52     6423520 :                         q1 ^= d1;
      53             : 
      54     6423520 :                         r0 = d2_32(r0);
      55     6423520 :                         r1 = d2_32(r1);
      56             : 
      57     6423520 :                         r0 ^= d0;
      58     6423520 :                         r1 ^= d1;
      59             :                 }
      60      917536 :                 v_32(p[i]) = p0;
      61      917536 :                 v_32(p[i + 4]) = p1;
      62      917536 :                 v_32(q[i]) = q0;
      63      917536 :                 v_32(q[i + 4]) = q1;
      64      917536 :                 v_32(r[i]) = r0;
      65      917536 :                 v_32(r[i + 4]) = r1;
      66             :         }
      67          29 : }
      68             : 
      69             : /*
      70             :  * GENz (triple parity with powers of 2^-1) 64bit C implementation
      71             :  */
      72          58 : void raid_genz_int64(int nd, size_t size, void **vv)
      73             : {
      74          58 :         uint8_t **v = (uint8_t**)vv;
      75             :         uint8_t *p;
      76             :         uint8_t *q;
      77             :         uint8_t *r;
      78             :         int d, l;
      79             :         size_t i;
      80             : 
      81             :         uint64_t d0, r0, q0, p0;
      82             :         uint64_t d1, r1, q1, p1;
      83             : 
      84          58 :         l = nd - 1;
      85          58 :         p = v[nd];
      86          58 :         q = v[nd + 1];
      87          58 :         r = v[nd + 2];
      88             : 
      89      933962 :         for (i = 0; i < size; i += 16) {
      90      933904 :                 r0 = q0 = p0 = v_64(v[l][i]);
      91      933904 :                 r1 = q1 = p1 = v_64(v[l][i + 8]);
      92     7471616 :                 for (d = l - 1; d >= 0; --d) {
      93     6537712 :                         d0 = v_64(v[d][i]);
      94     6537712 :                         d1 = v_64(v[d][i + 8]);
      95             : 
      96     6537712 :                         p0 ^= d0;
      97     6537712 :                         p1 ^= d1;
      98             : 
      99     6537712 :                         q0 = x2_64(q0);
     100     6537712 :                         q1 = x2_64(q1);
     101             : 
     102     6537712 :                         q0 ^= d0;
     103     6537712 :                         q1 ^= d1;
     104             : 
     105     6537712 :                         r0 = d2_64(r0);
     106     6537712 :                         r1 = d2_64(r1);
     107             : 
     108     6537712 :                         r0 ^= d0;
     109     6537712 :                         r1 ^= d1;
     110             :                 }
     111      933904 :                 v_64(p[i]) = p0;
     112      933904 :                 v_64(p[i + 8]) = p1;
     113      933904 :                 v_64(q[i]) = q0;
     114      933904 :                 v_64(q[i + 8]) = q1;
     115      933904 :                 v_64(r[i]) = r0;
     116      933904 :                 v_64(r[i + 8]) = r1;
     117             :         }
     118          58 : }
     119             :