← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to external/monomac/samples/CFNetwork/Models/BenchmarkRunner.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
external/monomac/samples/CFNetwork/Models/BenchmarkRunner.cs
 
1
//
 
2
// MonoMac.CFNetwork.Test.Models.BenchmarkRunner
 
3
//
 
4
// Authors:
 
5
//      Martin Baulig (martin.baulig@gmail.com)
 
6
//
 
7
// Copyright 2012 Xamarin Inc. (http://www.xamarin.com)
 
8
//
 
9
//
 
10
// Permission is hereby granted, free of charge, to any person obtaining
 
11
// a copy of this software and associated documentation files (the
 
12
// "Software"), to deal in the Software without restriction, including
 
13
// without limitation the rights to use, copy, modify, merge, publish,
 
14
// distribute, sublicense, and/or sell copies of the Software, and to
 
15
// permit persons to whom the Software is furnished to do so, subject to
 
16
// the following conditions:
 
17
// 
 
18
// The above copyright notice and this permission notice shall be
 
19
// included in all copies or substantial portions of the Software.
 
20
// 
 
21
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 
22
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 
23
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 
24
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 
25
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 
26
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 
27
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
28
//
 
29
using System;
 
30
using System.Net;
 
31
using System.Net.Http;
 
32
using System.Threading;
 
33
using System.Threading.Tasks;
 
34
using MonoMac.Foundation;
 
35
using MonoMac.CFNetwork;
 
36
 
 
37
namespace MonoMac.CFNetwork.Test.Models {
 
38
 
 
39
        using Views;
 
40
 
 
41
        public class BenchmarkRunner : AsyncTaskRunner {
 
42
                public override bool CanReportProgress {
 
43
                        get { return false; }
 
44
                }
 
45
 
 
46
                public override bool CanSendResponse {
 
47
                        get { return false; }
 
48
                }
 
49
 
 
50
                public event EventHandler<MessageEventArgs> DetailedMessageEvent;
 
51
 
 
52
                protected virtual void OnDetailedMessageEvent (object sender, MessageEventArgs args)
 
53
                {
 
54
                        if (DetailedMessageEvent != null)
 
55
                                DetailedMessageEvent (sender, args);
 
56
                }
 
57
 
 
58
                void Write (string message, params object[] args)
 
59
                {
 
60
                        Write (string.Format (message, args));
 
61
                }
 
62
 
 
63
                void Write (string message)
 
64
                {
 
65
                        OnDetailedMessageEvent (this, new MessageEventArgs (message));
 
66
                }
 
67
 
 
68
                void WriteLine (string message, params object[] args)
 
69
                {
 
70
                        Write (string.Format (message, args) + Environment.NewLine);
 
71
                }
 
72
 
 
73
                void WriteLine (string message)
 
74
                {
 
75
                        Write (message + Environment.NewLine);
 
76
                }
 
77
 
 
78
                BenchmarkViewController ViewController {
 
79
                        get { return AppDelegate.Instance.MainWindowController.BenchmarkController; }
 
80
                }
 
81
 
 
82
                Uri uri;
 
83
                int repeatCount;
 
84
                DateTime startTime;
 
85
                BenchmarkViewController.ModeTag mode;
 
86
                CancellationTokenSource cts;
 
87
 
 
88
                internal override async Task<string> Run (Uri uri, CancellationToken cancellationToken)
 
89
                {
 
90
                        if (cts != null)
 
91
                                throw new InvalidOperationException ();
 
92
 
 
93
                        this.uri = uri;
 
94
                        this.mode = (BenchmarkViewController.ModeTag)ViewController.Mode;
 
95
                        this.repeatCount = ViewController.RepeatCount;
 
96
                        cts = CancellationTokenSource.CreateLinkedTokenSource (cancellationToken);
 
97
 
 
98
                        var message = string.Format (
 
99
                                "Running {0} iterations of {1} ({2}).", repeatCount, mode, uri);
 
100
                        OnMessageEvent (message);
 
101
                        WriteLine (message);
 
102
 
 
103
                        startTime = DateTime.Now;
 
104
 
 
105
                        try {
 
106
                                await DoRun ();
 
107
                                var time = DateTime.Now - startTime;
 
108
                                var completed = string.Format ("Benchmark completed in {0}.", time);
 
109
                                WriteLine (completed);
 
110
                                WriteLine (string.Empty);
 
111
                                return message;
 
112
                        } finally {
 
113
                                cts.Dispose ();
 
114
                                cts = null;
 
115
                        }
 
116
                }
 
117
 
 
118
                protected override HttpClient CreateClient (bool defaultHandler)
 
119
                {
 
120
                        var client = base.CreateClient (defaultHandler);
 
121
                        cts.Token.Register (() => client.CancelPendingRequests ());
 
122
                        return client;
 
123
                }
 
124
 
 
125
                async Task DoRun ()
 
126
                {
 
127
                        await SingleRequest ();
 
128
                        await SerialRequests (true);
 
129
                        await SerialRequests (false);
 
130
                        await SerialRequestsOnWorker ();
 
131
                        // await ParallelRequests (true);
 
132
                        // await ParallelRequests (false);
 
133
                }
 
134
 
 
135
                async Task SingleRequest ()
 
136
                {
 
137
                        var start = DateTime.Now;
 
138
                        using (var client = CreateClient (false))
 
139
                                await CreateTask (client);
 
140
                        WriteLine ("Single request done in {0}.", DateTime.Now - start);
 
141
                }
 
142
 
 
143
                string GetHandlerName (bool defaultHandler)
 
144
                {
 
145
                        return defaultHandler ? "default" : "CFNetwork";
 
146
                }
 
147
 
 
148
                async Task SerialRequests (bool defaultHandler)
 
149
                {
 
150
                        WriteLine ("Starting {0} serial requests.", GetHandlerName (defaultHandler));
 
151
 
 
152
                        var start = DateTime.Now;
 
153
 
 
154
                        for (int i = 0; i < repeatCount; i++) {
 
155
                                using (var client = CreateClient (defaultHandler))
 
156
                                        await CreateTask (client);
 
157
                        }
 
158
 
 
159
                        var time = DateTime.Now - start;
 
160
                        var perRequest = (int)(time.TotalMilliseconds / repeatCount);
 
161
 
 
162
                        WriteLine ("Serial {0} requests done in {1} ({2}ms/request).",
 
163
                                   GetHandlerName (defaultHandler), time, perRequest);
 
164
                }
 
165
 
 
166
                async Task SerialRequestsOnWorker ()
 
167
                {
 
168
                        WriteLine ("Starting serial requests on worker thread.");
 
169
 
 
170
                        var worker = new WorkerThread ();
 
171
                        var handler = new MessageHandler (worker);
 
172
                        var client = new HttpClient (handler, true);
 
173
 
 
174
                        var start = DateTime.Now;
 
175
 
 
176
                        try {
 
177
                                for (int i = 0; i < repeatCount; i++) {
 
178
                                        await CreateTask (client);
 
179
                                }
 
180
                        } finally {
 
181
                                client.Dispose ();
 
182
                                worker.Stop ();
 
183
                        }
 
184
 
 
185
                        var time = DateTime.Now - start;
 
186
                        var perRequest = (int)(time.TotalMilliseconds / repeatCount);
 
187
 
 
188
                        WriteLine ("Serial requests on worker thread done in {0} ({1}ms/request).",
 
189
                                   time, perRequest);
 
190
                }
 
191
 
 
192
 
 
193
                async Task ParallelRequests (bool defaultHandler)
 
194
                {
 
195
                        WriteLine ("Starting {0} parallel requests.", GetHandlerName (defaultHandler));
 
196
 
 
197
                        var start = DateTime.Now;
 
198
 
 
199
                        var clients = new HttpClient [repeatCount];
 
200
                        var task = new Task [repeatCount];
 
201
 
 
202
                        for (int i = 0; i < task.Length; i++) {
 
203
                                clients [i] = CreateClient (defaultHandler);
 
204
                                task [i] = CreateTask (clients [i]);
 
205
                        }
 
206
 
 
207
                        await Task.WhenAll (task);
 
208
 
 
209
                        var time = DateTime.Now - start;
 
210
                        var perRequest = (int)(time.TotalMilliseconds / repeatCount);
 
211
 
 
212
                        WriteLine ("Parallel {0} requests done in {1} ({2}ms/request).",
 
213
                                   GetHandlerName (defaultHandler), time, perRequest);
 
214
                }
 
215
 
 
216
                Task CreateTask (HttpClient client)
 
217
                {
 
218
                        switch (mode) {
 
219
                        case BenchmarkViewController.ModeTag.GetByteArray:
 
220
                                return client.GetByteArrayAsync (uri);
 
221
 
 
222
                        case BenchmarkViewController.ModeTag.CheckHeaders:
 
223
                                return CheckHeaders (client);
 
224
 
 
225
                        default:
 
226
                                throw new InvalidOperationException ();
 
227
                        }
 
228
                }
 
229
 
 
230
                async Task CheckHeaders (HttpClient client)
 
231
                {
 
232
                        var request = new HttpRequestMessage (HttpMethod.Get, uri);
 
233
                        var response = await client.SendAsync (
 
234
                                request, HttpCompletionOption.ResponseHeadersRead, cts.Token);
 
235
                        response.Dispose ();
 
236
                }
 
237
        }
 
238
}