Esempio n. 1
0
        void IAnalyticsProxy.OnNextFork(Microsoft.StreamProcessing.StreamEvent <TwitterObservable.Tweet> p_0)
        {
            SerializableTaskCompletionSource rpcTask;

            // Compute size of serialized arguments
            var totalArgSize = 0;

            // Argument 0
            int arg0Size = 0;

            byte[] arg0Bytes = null;

            arg0Bytes = Ambrosia.BinarySerializer.Serialize <Microsoft.StreamProcessing.StreamEvent <TwitterObservable.Tweet> >(p_0);
            arg0Size  = IntSize(arg0Bytes.Length) + arg0Bytes.Length;

            totalArgSize += arg0Size;

            var wp = this.StartRPC <object>(1 /* method identifier for OnNext */, totalArgSize, out rpcTask, RpcTypes.RpcType.Impulse);

            // 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;


            this.ReleaseBufferAndSend();
            return;
        }
Esempio n. 2
0
        OnNextAsync(Microsoft.StreamProcessing.StreamEvent <TwitterObservable.Tweet> 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 <Microsoft.StreamProcessing.StreamEvent <TwitterObservable.Tweet> >(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;
        }
Esempio n. 3
0
 IAnalyticsProxy.OnNextAsync(Microsoft.StreamProcessing.StreamEvent <TwitterObservable.Tweet> p_0)
 {
     await OnNextAsync(p_0);
 }
Esempio n. 4
0
        OnNextAsync(Microsoft.StreamProcessing.StreamEvent <TwitterObservable.Tweet> 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 <Microsoft.StreamProcessing.StreamEvent <TwitterObservable.Tweet> >(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;

            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;

            while (currentResult.AdditionalInfoType != ResultAdditionalInfoTypes.SetResult)
            {
                switch (currentResult.AdditionalInfoType)
                {
                case ResultAdditionalInfoTypes.SaveContext:
                    await Immortal.SaveTaskContextAsync();

                    taskToWaitFor = Immortal.CallCache.Data[asyncContext.SequenceNumber].GetAwaitableTaskWithAdditionalInfoAsync();
                    break;

                case ResultAdditionalInfoTypes.TakeCheckpoint:
                    var sequenceNumber = await Immortal.TakeTaskCheckpointAsync();

                    Immortal.StartDispatchLoop();
                    taskToWaitFor = Immortal.GetTaskToWaitForWithAdditionalInfoAsync(sequenceNumber);
                    break;
                }

                currentResult = await taskToWaitFor;
            }

            lock (Immortal.DispatchTaskIdQueueLock)
            {
                Immortal.DispatchTaskIdQueue.Data.Enqueue(taskId);
            }
            return;
        }