Line data    Source code

       1             : // SPDX-License-Identifier: GPL-2.0-or-later
       2             : // Copyright (C) 2013 Andrea Mazzoleni
       3             : 
       4             : #include "internal.h"
       5             : #include "gf.h"
       6             : 
       7             : /*
       8             :  * GENz (triple parity with powers of 2^-1) 32bit C implementation
       9             :  */
      10          32 : void raid_genz_int32(int nd, size_t size, void **vv)
      11             : {
      12          32 :         uint8_t **v = (uint8_t**)vv;
      13             :         uint8_t *p;
      14             :         uint8_t *q;
      15             :         uint8_t *r;
      16             :         int d, l;
      17             :         size_t i;
      18             : 
      19             :         uint32_t d0, r0, q0, p0;
      20             :         uint32_t d1, r1, q1, p1;
      21             : 
      22          32 :         l = nd - 1;
      23          32 :         p = v[nd];
      24          32 :         q = v[nd + 1];
      25          32 :         r = v[nd + 2];
      26             : 
      27     1015872 :         for (i = 0; i < size; i += 8) {
      28     1015840 :                 r0 = q0 = p0 = v_32(v[l][i]);
      29     1015840 :                 r1 = q1 = p1 = v_32(v[l][i + 4]);
      30     8127488 :                 for (d = l - 1; d >= 0; --d) {
      31     7111648 :                         d0 = v_32(v[d][i]);
      32     7111648 :                         d1 = v_32(v[d][i + 4]);
      33             : 
      34     7111648 :                         p0 ^= d0;
      35     7111648 :                         p1 ^= d1;
      36             : 
      37     7111648 :                         q0 = x2_32(q0);
      38     7111648 :                         q1 = x2_32(q1);
      39             : 
      40     7111648 :                         q0 ^= d0;
      41     7111648 :                         q1 ^= d1;
      42             : 
      43     7111648 :                         r0 = d2_32(r0);
      44     7111648 :                         r1 = d2_32(r1);
      45             : 
      46     7111648 :                         r0 ^= d0;
      47     7111648 :                         r1 ^= d1;
      48             :                 }
      49     1015840 :                 v_32(p[i]) = p0;
      50     1015840 :                 v_32(p[i + 4]) = p1;
      51     1015840 :                 v_32(q[i]) = q0;
      52     1015840 :                 v_32(q[i + 4]) = q1;
      53     1015840 :                 v_32(r[i]) = r0;
      54     1015840 :                 v_32(r[i + 4]) = r1;
      55             :         }
      56          32 : }
      57             : 
      58             : /*
      59             :  * GENz (triple parity with powers of 2^-1) 64bit C implementation
      60             :  */
      61          57 : void raid_genz_int64(int nd, size_t size, void **vv)
      62             : {
      63          57 :         uint8_t **v = (uint8_t**)vv;
      64             :         uint8_t *p;
      65             :         uint8_t *q;
      66             :         uint8_t *r;
      67             :         int d, l;
      68             :         size_t i;
      69             : 
      70             :         uint64_t d0, r0, q0, p0;
      71             :         uint64_t d1, r1, q1, p1;
      72             : 
      73          57 :         l = nd - 1;
      74          57 :         p = v[nd];
      75          57 :         q = v[nd + 1];
      76          57 :         r = v[nd + 2];
      77             : 
      78      917577 :         for (i = 0; i < size; i += 16) {
      79      917520 :                 r0 = q0 = p0 = v_64(v[l][i]);
      80      917520 :                 r1 = q1 = p1 = v_64(v[l][i + 8]);
      81     7340544 :                 for (d = l - 1; d >= 0; --d) {
      82     6423024 :                         d0 = v_64(v[d][i]);
      83     6423024 :                         d1 = v_64(v[d][i + 8]);
      84             : 
      85     6423024 :                         p0 ^= d0;
      86     6423024 :                         p1 ^= d1;
      87             : 
      88     6423024 :                         q0 = x2_64(q0);
      89     6423024 :                         q1 = x2_64(q1);
      90             : 
      91     6423024 :                         q0 ^= d0;
      92     6423024 :                         q1 ^= d1;
      93             : 
      94     6423024 :                         r0 = d2_64(r0);
      95     6423024 :                         r1 = d2_64(r1);
      96             : 
      97     6423024 :                         r0 ^= d0;
      98     6423024 :                         r1 ^= d1;
      99             :                 }
     100      917520 :                 v_64(p[i]) = p0;
     101      917520 :                 v_64(p[i + 8]) = p1;
     102      917520 :                 v_64(q[i]) = q0;
     103      917520 :                 v_64(q[i + 8]) = q1;
     104      917520 :                 v_64(r[i]) = r0;
     105      917520 :                 v_64(r[i + 8]) = r1;
     106             :         }
     107          57 : }
     108             :