Exemplo n.º 1
0
        PrintBytesReceivedAsync()
        {
            SerializableTaskCompletionSource rpcTask;
            // Make call, wait for reply
            // Compute size of serialized arguments
            var totalArgSize = 0;


            var wp           = this.StartRPC <object>(methodIdentifier: 1 /* method identifier for PrintBytesReceived */, lengthOfSerializedArguments: totalArgSize, taskToWaitFor: out rpcTask);
            var asyncContext = new AsyncContext {
                SequenceNumber = Immortal.CurrentSequenceNumber
            };

            // Serialize arguments


            ReleaseBufferAndSend();

            var taskToWaitFor = Immortal.CallCache.Data[asyncContext.SequenceNumber].GetAwaitableTaskWithAdditionalInfoAsync();
            var currentResult = await taskToWaitFor;

            var isSaved = await Immortal.TrySaveContextContinuationAsync(currentResult);

            if (isSaved)
            {
                taskToWaitFor = Immortal.CallCache.Data[asyncContext.SequenceNumber].GetAwaitableTaskWithAdditionalInfoAsync();
                currentResult = await taskToWaitFor;
            }

            await Immortal.TryTakeCheckpointContinuationAsync(currentResult);

            return;
        }
Exemplo n.º 2
0
        ReceiveMessageAsync(System.String p_0)
        {
            SerializableTaskCompletionSource rpcTask;
            // Make call, wait for reply
            // Compute size of serialized arguments
            var totalArgSize = 0;

            var p_1      = default(Int32);
            int arg0Size = 0;

            byte[] arg0Bytes = null;

            // Argument 0
            arg0Bytes = Ambrosia.BinarySerializer.Serialize <System.String>(p_0);
            arg0Size  = IntSize(arg0Bytes.Length) + arg0Bytes.Length;

            totalArgSize += arg0Size;

            var wp           = this.StartRPC <Int32>(methodIdentifier: 1 /* method identifier for ReceiveMessage */, lengthOfSerializedArguments: totalArgSize, taskToWaitFor: out rpcTask);
            var asyncContext = new AsyncContext {
                SequenceNumber = Immortal.CurrentSequenceNumber
            };

            // Serialize arguments


            // Serialize arg0
            wp.curLength += wp.PageBytes.WriteInt(wp.curLength, arg0Bytes.Length);
            Buffer.BlockCopy(arg0Bytes, 0, wp.PageBytes, wp.curLength, arg0Bytes.Length);
            wp.curLength += arg0Bytes.Length;

            int taskId;

            lock (Immortal.DispatchTaskIdQueueLock)
            {
                while (!Immortal.DispatchTaskIdQueue.Data.TryDequeue(out taskId))
                {
                }
            }

            ReleaseBufferAndSend();

            Immortal.StartDispatchLoop();

            var taskToWaitFor = Immortal.CallCache.Data[asyncContext.SequenceNumber].GetAwaitableTaskWithAdditionalInfoAsync();
            var currentResult = await taskToWaitFor;

            var isSaved = await Immortal.TrySaveContextContinuationAsync(currentResult);

            if (isSaved)
            {
                taskToWaitFor = Immortal.CallCache.Data[asyncContext.SequenceNumber].GetAwaitableTaskWithAdditionalInfoAsync();
                currentResult = await taskToWaitFor;
            }

            var result = await Immortal.TryTakeCheckpointContinuationAsync(currentResult, taskId);

            return((Int32)result.Result);
        }
Exemplo n.º 3
0
        MAsync(System.Byte[] p_0)
        {
            SerializableTaskCompletionSource rpcTask;
            // Make call, wait for reply
            // Compute size of serialized arguments
            var totalArgSize = 0;

            var p_1      = default(Byte[]);
            int arg0Size = 0;

            byte[] arg0Bytes = null;

            // Argument 0
            arg0Bytes = p_0;
            arg0Size  = IntSize(arg0Bytes.Length) + arg0Bytes.Length;

            totalArgSize += arg0Size;

            var wp           = this.StartRPC <Byte[]>(methodIdentifier: 1 /* method identifier for M */, lengthOfSerializedArguments: totalArgSize, taskToWaitFor: out rpcTask);
            var asyncContext = new AsyncContext {
                SequenceNumber = Immortal.CurrentSequenceNumber
            };

            // Serialize arguments


            // Serialize arg0
            wp.curLength += wp.PageBytes.WriteInt(wp.curLength, arg0Bytes.Length);
            Buffer.BlockCopy(arg0Bytes, 0, wp.PageBytes, wp.curLength, arg0Bytes.Length);
            wp.curLength += arg0Bytes.Length;


            ReleaseBufferAndSend();

            var taskToWaitFor = Immortal.CallCache.Data[asyncContext.SequenceNumber].GetAwaitableTaskWithAdditionalInfoAsync();
            var currentResult = await taskToWaitFor;

            var isSaved = await Immortal.TrySaveContextContinuationAsync(currentResult);

            if (isSaved)
            {
                taskToWaitFor = Immortal.CallCache.Data[asyncContext.SequenceNumber].GetAwaitableTaskWithAdditionalInfoAsync();
                currentResult = await taskToWaitFor;
            }

            var result = await Immortal.TryTakeCheckpointContinuationAsync(currentResult);

            return((Byte[])result.Result);
        }
Exemplo n.º 4
0
        OnNextAsync(TwitterObservable.AnalyticsResultString p_0)
        {
            SerializableTaskCompletionSource rpcTask;
            // Make call, wait for reply
            // Compute size of serialized arguments
            var totalArgSize = 0;

            int arg0Size = 0;

            byte[] arg0Bytes = null;

            // Argument 0
            arg0Bytes = Ambrosia.BinarySerializer.Serialize <TwitterObservable.AnalyticsResultString>(p_0);
            arg0Size  = IntSize(arg0Bytes.Length) + arg0Bytes.Length;

            totalArgSize += arg0Size;

            var wp           = this.StartRPC <object>(methodIdentifier: 1 /* method identifier for OnNext */, lengthOfSerializedArguments: totalArgSize, taskToWaitFor: out rpcTask);
            var asyncContext = new AsyncContext {
                SequenceNumber = Immortal.CurrentSequenceNumber
            };

            // Serialize arguments


            // Serialize arg0
            wp.curLength += wp.PageBytes.WriteInt(wp.curLength, arg0Bytes.Length);
            Buffer.BlockCopy(arg0Bytes, 0, wp.PageBytes, wp.curLength, arg0Bytes.Length);
            wp.curLength += arg0Bytes.Length;


            ReleaseBufferAndSend();

            var taskToWaitFor = Immortal.CallCache.Data[asyncContext.SequenceNumber].GetAwaitableTaskWithAdditionalInfoAsync();
            var currentResult = await taskToWaitFor;

            var isSaved = await Immortal.TrySaveContextContinuationAsync(currentResult);

            if (isSaved)
            {
                taskToWaitFor = Immortal.CallCache.Data[asyncContext.SequenceNumber].GetAwaitableTaskWithAdditionalInfoAsync();
                currentResult = await taskToWaitFor;
            }

            await Immortal.TryTakeCheckpointContinuationAsync(currentResult);

            return;
        }