erasurecodec.java

pastry的java实现的2.0b版

      }
    }

    // *** Last step ***

    for (int row = 0; row < nExtra; row++) {
      for (int col = 0; col < nExtra; col++) {
        int exponent = (int) InvMat[row][col];
        for (int row_bit = 0; row_bit < Lfield; row_bit++) {
          for (int col_bit = 0; col_bit < Lfield; col_bit++) {
            if ((ExpToFieldElt[exponent + row_bit] & (1 << col_bit)) != 0) {
              buffer[row_bit + ColInd[row] * Lfield] ^= M[col_bit + col * Lfield];
            }
          }
        }
      }
    }
  }

  /**
   * DESCRIBE THE METHOD
   *
   * @param frag DESCRIBE THE PARAMETER
   * @param endpoint DESCRIBE THE PARAMETER
   * @param pcd DESCRIBE THE PARAMETER
   * @return DESCRIBE THE RETURN VALUE
   */
  public PastContent decode(Fragment frag[], Endpoint endpoint, PastContentDeserializer pcd) {

    Fragment firstFrag = null;
    for (int i = 0; i < frag.length; i++) {
      if (frag[i] != null) {
        firstFrag = frag[i];
      }
    }

    // System.out.println(Systemm.currentTimeMillis()+" XXX before decode("+firstFrag.getPayload().length+" bytes per fragment) free="+Runtime.getRuntime().freeMemory()+" total="+Runtime.getRuntime().totalMemory());

    if (frag.length != numFragments) {
      return null;
    }

    int firstFragment = -1;
    for (int i = 0; (i < numFragments) && (firstFragment == -1); i++) {
      if (frag[i] != null) {
        firstFragment = i;
      }
    }

    int wordsPerFragment = (frag[firstFragment].payload.length + 3) / 4;
    int numGroups = wordsPerFragment / Lfield;

    boolean haveFragment[] = new boolean[numFragments];
    Arrays.fill(haveFragment, false);

    for (int i = 0; i < numFragments; i++) {
      if (frag[i] != null) {
        haveFragment[i] = true;
      }
    }

    int ColInd[] = new int[numSurvivors];
    int RowInd[] = new int[numFragments - numSurvivors];

    int nMissing = 0;

    int nExtra = 0;
    for (int i = 0; i < numSurvivors; i++) {
      if (!haveFragment[i]) {
        ColInd[nMissing++] = i;
      }
    }

    for (int i = 0; i < (numFragments - numSurvivors); i++) {
      if (haveFragment[numSurvivors + i]) {
        RowInd[nExtra++] = i;
      }
    }

    if (nMissing > nExtra) {
      return null;
    }

    if (nMissing < nExtra) {
      nExtra = nMissing;
    }

    int[] C;

    int[] D;

    int[] E;

    int[] F;
    C = new int[numFragments - numSurvivors];
    Arrays.fill(C, 0);
    D = new int[numFragments - numSurvivors];
    Arrays.fill(D, 0);
    E = new int[numFragments - numSurvivors];
    Arrays.fill(E, 0);
    F = new int[numFragments - numSurvivors];
    Arrays.fill(F, 0);

    for (int row = 0; row < nExtra; row++) {
      for (int col = 0; col < nExtra; col++) {
        if (col != row) {
          C[row] += FieldEltToExp[RowInd[row] ^ RowInd[col]];
          D[row] += FieldEltToExp[ColInd[row] ^ ColInd[col]];
        }

        E[row] += FieldEltToExp[RowInd[row] ^ ColInd[col] ^ (1 << (Lfield - 1))];
        F[col] += FieldEltToExp[RowInd[row] ^ ColInd[col] ^ (1 << (Lfield - 1))];
      }
    }

    long InvMat[][] = new long[nExtra][nExtra];

    for (int row = 0; row < nExtra; row++) {
      for (int col = 0; col < nExtra; col++) {
        InvMat[row][col] = E[col] + F[row] - C[col] - D[row] -
          FieldEltToExp[RowInd[col] ^ ColInd[row] ^ (1 << (Lfield - 1))];
        if (InvMat[row][col] >= 0) {
          InvMat[row][col] = InvMat[row][col] % MultField;
        } else {
          InvMat[row][col] = (MultField - (-InvMat[row][col] % MultField)) % MultField;
        }
      }
    }

    // *** Second last step ***

    byte[] bytes = new byte[numSurvivors * wordsPerFragment * 4];
    int[] buffer = new int[numFragments * Lfield];
    for (int g = 0; g < numGroups; g++) {
      Arrays.fill(buffer, 0);
      for (int i = 0; i < numFragments; i++) {
        if (haveFragment[i]) {
          for (int j = 0; j < Lfield; j++) {
            buffer[i * Lfield + j] =
              ((frag[i].payload[4 * (g * Lfield + j) + 0]) & 0x0000FF) +
              ((frag[i].payload[4 * (g * Lfield + j) + 1] << 8) & 0x00FF00) +
              ((frag[i].payload[4 * (g * Lfield + j) + 2] << 16) & 0xFF0000) +
              (frag[i].payload[4 * (g * Lfield + j) + 3] << 24);
          }
        }
      }

      decodeChunk(buffer, nExtra, RowInd, haveFragment, InvMat, ColInd);

      for (int i = 0; i < (numSurvivors * Lfield); i++) {
        bytes[4 * (g * (numSurvivors * Lfield) + i) + 0] = (byte) (buffer[i] >> 24);
        bytes[4 * (g * (numSurvivors * Lfield) + i) + 1] = (byte) ((buffer[i] >> 16) & 0xFF);
        bytes[4 * (g * (numSurvivors * Lfield) + i) + 2] = (byte) ((buffer[i] >> 8) & 0xFF);
        bytes[4 * (g * (numSurvivors * Lfield) + i) + 3] = (byte) ((buffer[i]) & 0xFF);
      }
    }

    try {
      return deserialize(bytes, endpoint, pcd);
//      SimpleInputBuffer sib = new SimpleInputBuffer(bytes);
//      short type = sib.readShort();
//      return pcd.deserializePastContent(sib, endpoint, type);

//      ByteArrayInputStream byteinput = new ByteArrayInputStream(bytes);
//      ObjectInputStream objectInput = new ObjectInputStream(byteinput);
//      // System.out.println(Systemm.currentTimeMillis()+" XXX after decode("+firstFrag.getPayload().length+" bytes per fragment) free="+Runtime.getRuntime().freeMemory()+" total="+Runtime.getRuntime().totalMemory());
//      return (Serializable) objectInput.readObject();
    } catch (IOException ioe) {
      if (logger.level <= Logger.WARNING) {
        logger.logException(
          "", ioe);
      }
    } catch (ClassNotFoundException cnfe) {
      if (logger.level <= Logger.WARNING) {
        logger.logException(
          "", cnfe);
      }
    } catch (IllegalStateException ise) {
      if (logger.level <= Logger.WARNING) {
        logger.logException(
          "", ise);
      }
    }

    return null;
  }

  /**
   * DESCRIBE THE METHOD
   *
   * @param bytes DESCRIBE THE PARAMETER
   * @param endpoint DESCRIBE THE PARAMETER
   * @param pcd DESCRIBE THE PARAMETER
   * @return DESCRIBE THE RETURN VALUE
   * @exception IOException DESCRIBE THE EXCEPTION
   * @exception ClassNotFoundException DESCRIBE THE EXCEPTION
   */
  protected PastContent deserialize(byte[] bytes, Endpoint endpoint, PastContentDeserializer pcd) throws IOException, ClassNotFoundException {
//  ByteArrayInputStream byteinput = new ByteArrayInputStream(bytes);
//  ObjectInputStream objectInput = new ObjectInputStream(byteinput);
//  // System.out.println(Systemm.currentTimeMillis()+" XXX after decode("+firstFrag.getPayload().length+" bytes per fragment) free="+Runtime.getRuntime().freeMemory()+" total="+Runtime.getRuntime().totalMemory());
//  return (Serializable) objectInput.readObject();

    SimpleInputBuffer sib = new SimpleInputBuffer(bytes);
    short type = sib.readShort();
    return pcd.deserializePastContent(sib, endpoint, type);
  }

  /**
   * DESCRIBE THE METHOD
   */
  protected void initElt() {
    final int polymask[] = {
      0x0000, 0x0003, 0x0007, 0x000B, 0x0013, 0x0025, 0x0043, 0x0083,
      0x011D, 0x0211, 0x0409, 0x0805, 0x1053, 0x201B, 0x402B, 0x8003
      };

    ExpToFieldElt = new int[MultField + Lfield];

    ExpToFieldElt[0] = 1;
    for (int i = 1; i < MultField + Lfield - 1; i++) {
      ExpToFieldElt[i] = ExpToFieldElt[i - 1] << 1;
      if ((ExpToFieldElt[i] & (1 << Lfield)) != 0) {
        ExpToFieldElt[i] ^= polymask[Lfield];
      }
    }

    /*
     *  This is the inverter for the previous field. Note that 0
     *  is not invertible!
     */
    FieldEltToExp = new int[MultField + 1];

    FieldEltToExp[0] = -1;
    for (int i = 0; i < MultField; i++) {
      FieldEltToExp[ExpToFieldElt[i]] = i;
    }
  }

//  public static void main(String args[]) {
//    Environment env = new Environment();
//    RandomSource rng = env.getRandomSource();
//    ErasureCodec codec = new ErasureCodec(48, 5, env);
//    Serializable s = new String("Habe Mut, Dich Deines eigenen Verstandes zu bedienen! Aufklaerung ist der Ausgang aus Deiner selbstverschuldeten Unmuendigkeit!");
//
//    System.out.println("Encoding...");
//
//    boolean generateFragment[] = new boolean[48];
//    Arrays.fill(generateFragment, true);
//
//    Fragment frag[] = codec.encodeObject(s, generateFragment);
//
//    Fragment frag2[] = new Fragment[48];
//    frag2[9] = frag[9];
//    frag2[11] = frag[11];
//    frag2[12] = frag[12];
//    frag2[17] = frag[17];
//    frag2[33] = frag[33];
//
//    System.out.println("Decoding...");
//    Object d = codec.decode(frag2);
//
//    System.out.println(d);
//
//    for (int i=0; i<100; i++) {
//      int[] theObject = new int[rng.nextInt(100000)];
//      for (int j=0; j<theObject.length; j++)
//        theObject[j] = rng.nextInt(2000000000);
//
//      System.out.println("#"+i+": "+(theObject.length*4)+" bytes");
//
//      int fid[] = new int[5];
//      for (int j=0; j<5; j++) {
//        boolean again = true;
//        while (again) {
//          fid[j] = rng.nextInt(48);
//          again = false;
//          for (int k=0; k<j; k++)
//            if (fid[k] == fid[j])
//              again = true;
//        }
//      }
//
//      generateFragment = new boolean[48];
//      for (int j=0; j<48; j++)
//        generateFragment[j] = false;
//      for (int j=0; j<5; j++)
//        generateFragment[fid[j]] = true;
//
//      Fragment xf[] = codec.encodeObject(theObject, generateFragment);
//
//      Fragment yf[] = new Fragment[48];
//      for (int j=0; j<5; j++)
//        yf[fid[j]] = xf[fid[j]];
//
//      int[] decodedObject = (int[]) codec.decode(yf);
//
//      for (int j=0; j<theObject.length; j++) {
//        if (decodedObject[j] != theObject[j]) {
//          System.err.println("FAIL: Run #"+i+" offset "+j+" decoded="+decodedObject[j]+" original="+theObject[j]);
//          System.exit(1);
//        }
//      }
//    }
//
//    System.out.println("PASS");
//  }
}