private async Task <BigInteger[]> ReadGroupElements(IMessageChannel channel, int numberOfGroupElements) { MessageDecomposer message = new MessageDecomposer(await channel.ReadMessageAsync()); BigInteger[] groupElements = new BigInteger[numberOfGroupElements]; for (int i = 0; i < numberOfGroupElements; ++i) { int length = message.ReadInt(); byte[] packedGroupElement = message.ReadBuffer(length); groupElements[i] = new BigInteger(packedGroupElement); } return(groupElements); }
private async Task <byte[][][]> ReadOptions(IMessageChannel channel, int numberOfOptions, int numberOfInvocations, int numberOfMessageBytes) { MessageDecomposer message = new MessageDecomposer(await channel.ReadMessageAsync()); byte[][][] options = new byte[numberOfInvocations][][]; for (int j = 0; j < numberOfInvocations; ++j) { options[j] = new byte[numberOfOptions][]; for (int i = 0; i < numberOfOptions; ++i) { options[j][i] = message.ReadBuffer(numberOfMessageBytes); } } return(options); }
protected override async Task <byte[][]> GeneralizedReceiveAsync(IMessageChannel channel, QuadrupleIndexArray selectionIndices, int numberOfInvocations, int numberOfMessageBytes) { byte[] packedOptions = await channel.ReadMessageAsync(); if (packedOptions.Length != 4 * numberOfInvocations * numberOfMessageBytes) { throw new DesynchronizationException("Received incorrect number of options."); } byte[][] selectedMessages = new byte[numberOfInvocations][]; for (int i = 0; i < numberOfInvocations; ++i) { selectedMessages[i] = new byte[numberOfMessageBytes]; Buffer.BlockCopy(packedOptions, (4 * i + selectionIndices[i]) * numberOfMessageBytes, selectedMessages[i], 0, numberOfMessageBytes); } return(selectedMessages); }
public async Task <BitArray> ReceiveAsync(IMessageChannel channel, QuadrupleIndexArray selectionIndices, int numberOfInvocations) { if (selectionIndices.Length != numberOfInvocations) { throw new ArgumentException("Provided selection indices must match the specified number of invocations.", nameof(selectionIndices)); } if (_receiverBatch == null || _nextReceiverInstanceId + numberOfInvocations > _receiverBatch.NumberOfInstances) { throw new InvalidOperationException("Not enough preprocessed receiver data available."); } QuadrupleIndexArray deltaSelectionIndices = new QuadrupleIndexArray(numberOfInvocations); for (int i = 0; i < numberOfInvocations; ++i) { int deltaSelectionIndex = (_receiverBatch.GetSelectionIndex(_nextReceiverInstanceId + i) - selectionIndices[i] + 4) % 4; deltaSelectionIndices[i] = deltaSelectionIndex; } await channel.WriteMessageAsync(deltaSelectionIndices.ToBytes()); byte[] packedMaskedOptionQuadruples = await channel.ReadMessageAsync(); if (packedMaskedOptionQuadruples.Length != BitQuadrupleArray.RequiredBytes(numberOfInvocations)) { throw new DesynchronizationException("Received incorrect number of masked option quadruples."); } BitQuadrupleArray maskedOptionQuadruples = BitQuadrupleArray.FromBytes(packedMaskedOptionQuadruples, numberOfInvocations); BitArray selectedBits = new BitArray(numberOfInvocations); for (int i = 0; i < numberOfInvocations; ++i) { BitQuadruple maskedOptions = maskedOptionQuadruples[i]; selectedBits[i] = maskedOptions[selectionIndices[i]] ^ _receiverBatch.GetSelectedOption(_nextReceiverInstanceId + i); } _nextReceiverInstanceId += numberOfInvocations; return(selectedBits); }
public async Task SendAsync(IMessageChannel channel, BitQuadrupleArray options, int numberOfInvocations) { if (options.Length != numberOfInvocations) { throw new ArgumentException("Provided options must match the specified number of invocations.", nameof(options)); } if (_senderBatch == null || _nextSenderInstanceId + numberOfInvocations > _senderBatch.NumberOfInstances) { throw new InvalidOperationException("Not enough preprocessed sender data available."); } byte[] packedDeltaSelectionIndices = await channel.ReadMessageAsync(); if (packedDeltaSelectionIndices.Length != QuadrupleIndexArray.RequiredBytes(numberOfInvocations)) { throw new DesynchronizationException("Received incorrect number of delta selection indices."); } QuadrupleIndexArray deltaSelectionIndices = QuadrupleIndexArray.FromBytes(packedDeltaSelectionIndices, numberOfInvocations); BitQuadrupleArray maskedOptionQuadruples = new BitQuadrupleArray(numberOfInvocations); for (int i = 0; i < numberOfInvocations; ++i) { int deltaSelectionIndex = deltaSelectionIndices[i]; BitQuadruple preprocessedOptions = _senderBatch.GetOptions(_nextSenderInstanceId + i); BitQuadruple unmaskedOptions = options[i]; BitQuadruple maskedOptions = new BitQuadruple( unmaskedOptions[0] ^ preprocessedOptions[(0 + deltaSelectionIndex) % 4], unmaskedOptions[1] ^ preprocessedOptions[(1 + deltaSelectionIndex) % 4], unmaskedOptions[2] ^ preprocessedOptions[(2 + deltaSelectionIndex) % 4], unmaskedOptions[3] ^ preprocessedOptions[(3 + deltaSelectionIndex) % 4] ); maskedOptionQuadruples[i] = maskedOptions; } await channel.WriteMessageAsync(maskedOptionQuadruples.ToBytes()); _nextSenderInstanceId += numberOfInvocations; }
public static async Task <byte[][][]> ReadOptionsAsync(IMessageChannel channel, int numberOfOptions, int numberOfInvocations, int numberOfMessageBytes) { byte[] messageBuffer = await channel.ReadMessageAsync(); byte[][][] result = new byte[numberOfInvocations][][]; Parallel.For(0, numberOfInvocations, i => { result[i] = new byte[numberOfOptions][]; for (int j = 0; j < numberOfOptions; ++j) { result[i][j] = new byte[numberOfMessageBytes]; Buffer.BlockCopy( messageBuffer, (numberOfOptions * numberOfMessageBytes) * i + j * numberOfMessageBytes, result[i][j], 0, numberOfMessageBytes ); } }); return(result); }