The Tor Browser / file comparison

comparison: netwerk/test/TestFileInput2.cpp

netwerk/test/TestFileInput2.cpp

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:dfaa62c13f2e
1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 #include "nsIServiceManager.h"
7 #include "nsIComponentRegistrar.h"
8 #include "nsIInputStream.h"
9 #include "nsIOutputStream.h"
10 #include "nsIRunnable.h"
11 #include "nsIThread.h"
12 #include "nsCOMArray.h"
13 #include "nsISimpleEnumerator.h"
14 #include "prinrval.h"
15 #include "nsIFileStreams.h"
16 #include "nsIFileChannel.h"
17 #include "nsIFile.h"
18 #include "nsNetUtil.h"
19 #include <stdio.h>
20
21 ////////////////////////////////////////////////////////////////////////////////
22
23 #include <math.h>
24 #include "prprf.h"
25 #include "nsAutoLock.h"
26
27 class nsTimeSampler {
28 public:
29 nsTimeSampler();
30 void Reset();
31 void StartTime();
32 void EndTime();
33 void AddTime(PRIntervalTime time);
34 PRIntervalTime LastInterval() { return mLastInterval; }
35 char* PrintStats();
36 protected:
37 PRIntervalTime mStartTime;
38 double mSquares;
39 double mTotalTime;
40 uint32_t mCount;
41 PRIntervalTime mLastInterval;
42 };
43
44 nsTimeSampler::nsTimeSampler()
45 {
46 Reset();
47 }
48
49 void
50 nsTimeSampler::Reset()
51 {
52 mStartTime = 0;
53 mSquares = 0;
54 mTotalTime = 0;
55 mCount = 0;
56 mLastInterval = 0;
57 }
58
59 void
60 nsTimeSampler::StartTime()
61 {
62 mStartTime = PR_IntervalNow();
63 }
64
65 void
66 nsTimeSampler::EndTime()
67 {
68 NS_ASSERTION(mStartTime != 0, "Forgot to call StartTime");
69 PRIntervalTime endTime = PR_IntervalNow();
70 mLastInterval = endTime - mStartTime;
71 AddTime(mLastInterval);
72 mStartTime = 0;
73 }
74
75 void
76 nsTimeSampler::AddTime(PRIntervalTime time)
77 {
78 nsAutoCMonitor mon(this);
79 mTotalTime += time;
80 mSquares += (double)time * (double)time;
81 mCount++;
82 }
83
84 char*
85 nsTimeSampler::PrintStats()
86 {
87 double mean = mTotalTime / mCount;
88 double variance = fabs(mSquares / mCount - mean * mean);
89 double stddev = sqrt(variance);
90 uint32_t imean = (uint32_t)mean;
91 uint32_t istddev = (uint32_t)stddev;
92 return PR_smprintf("%d +/- %d ms",
93 PR_IntervalToMilliseconds(imean),
94 PR_IntervalToMilliseconds(istddev));
95 }
96
97 ////////////////////////////////////////////////////////////////////////////////
98
99 nsTimeSampler gTimeSampler;
100
101 typedef nsresult (*CreateFun)(nsIRunnable* *result,
102 nsIFile* inPath,
103 nsIFile* outPath,
104 uint32_t bufferSize);
105
106 ////////////////////////////////////////////////////////////////////////////////
107
108 nsresult
109 Copy(nsIInputStream* inStr, nsIOutputStream* outStr,
110 char* buf, uint32_t bufSize, uint32_t *copyCount)
111 {
112 nsresult rv;
113 while (true) {
114 uint32_t count;
115 rv = inStr->Read(buf, bufSize, &count);
116 if (NS_FAILED(rv)) return rv;
117 if (count == 0) break;
118
119 uint32_t writeCount;
120 rv = outStr->Write(buf, count, &writeCount);
121 if (NS_FAILED(rv)) return rv;
122 NS_ASSERTION(writeCount == count, "didn't write all the data");
123 *copyCount += writeCount;
124 }
125 rv = outStr->Flush();
126 return rv;
127 }
128
129 ////////////////////////////////////////////////////////////////////////////////
130
131 class FileSpecWorker : public nsIRunnable {
132 public:
133
134 NS_IMETHOD Run() {
135 nsresult rv;
136
137 PRIntervalTime startTime = PR_IntervalNow();
138 PRIntervalTime endTime;
139 nsCOMPtr<nsIInputStream> inStr;
140 nsCOMPtr<nsIOutputStream> outStr;
141 uint32_t copyCount = 0;
142
143 // Open the input stream:
144 nsCOMPtr<nsIInputStream> fileIn;
145 rv = NS_NewLocalFileInputStream(getter_AddRefs(fileIn), mInPath);
146 if (NS_FAILED(rv)) return rv;
147
148 rv = NS_NewBufferedInputStream(getter_AddRefs(inStr), fileIn, 65535);
149 if (NS_FAILED(rv)) return rv;
150
151 // Open the output stream:
152 nsCOMPtr<nsIOutputStream> fileOut;
153 rv = NS_NewLocalFileOutputStream(getter_AddRefs(fileOut),
154 mOutPath,
155 PR_CREATE_FILE | PR_WRONLY | PR_TRUNCATE,
156 0664);
157 if (NS_FAILED(rv)) return rv;
158
159 rv = NS_NewBufferedOutputStream(getter_AddRefs(outStr), fileOut, 65535);
160 if (NS_FAILED(rv)) return rv;
161
162 // Copy from one to the other
163 rv = Copy(inStr, outStr, mBuffer, mBufferSize, &copyCount);
164 if (NS_FAILED(rv)) return rv;
165
166 endTime = PR_IntervalNow();
167 gTimeSampler.AddTime(endTime - startTime);
168
169 return rv;
170 }
171
172 NS_DECL_ISUPPORTS
173
174 FileSpecWorker()
175 : mInPath(nullptr), mOutPath(nullptr), mBuffer(nullptr),
176 mBufferSize(0)
177 {
178 }
179
180 nsresult Init(nsIFile* inPath, nsIFile* outPath,
181 uint32_t bufferSize)
182 {
183 mInPath = inPath;
184 mOutPath = outPath;
185 mBuffer = new char[bufferSize];
186 mBufferSize = bufferSize;
187 return (mInPath && mOutPath && mBuffer)
188 ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
189 }
190
191 static nsresult Create(nsIRunnable* *result,
192 nsIFile* inPath,
193 nsIFile* outPath,
194 uint32_t bufferSize)
195 {
196 FileSpecWorker* worker = new FileSpecWorker();
197 if (worker == nullptr)
198 return NS_ERROR_OUT_OF_MEMORY;
199 NS_ADDREF(worker);
200
201 nsresult rv = worker->Init(inPath, outPath, bufferSize);
202 if (NS_FAILED(rv)) {
203 NS_RELEASE(worker);
204 return rv;
205 }
206 *result = worker;
207 return NS_OK;
208 }
209
210 virtual ~FileSpecWorker() {
211 delete[] mBuffer;
212 }
213
214 protected:
215 nsCOMPtr<nsIFile> mInPath;
216 nsCOMPtr<nsIFile> mOutPath;
217 char* mBuffer;
218 uint32_t mBufferSize;
219 };
220
221 NS_IMPL_ISUPPORTS(FileSpecWorker, nsIRunnable)
222
223 ////////////////////////////////////////////////////////////////////////////////
224
225 #include "nsIIOService.h"
226 #include "nsIChannel.h"
227
228 class FileChannelWorker : public nsIRunnable {
229 public:
230
231 NS_IMETHOD Run() {
232 nsresult rv;
233
234 PRIntervalTime startTime = PR_IntervalNow();
235 PRIntervalTime endTime;
236 uint32_t copyCount = 0;
237 nsCOMPtr<nsIFileChannel> inCh;
238 nsCOMPtr<nsIFileChannel> outCh;
239 nsCOMPtr<nsIInputStream> inStr;
240 nsCOMPtr<nsIOutputStream> outStr;
241
242 rv = NS_NewLocalFileChannel(getter_AddRefs(inCh), mInPath);
243 if (NS_FAILED(rv)) return rv;
244
245 rv = inCh->Open(getter_AddRefs(inStr));
246 if (NS_FAILED(rv)) return rv;
247
248 //rv = NS_NewLocalFileChannel(getter_AddRefs(outCh), mOutPath);
249 //if (NS_FAILED(rv)) return rv;
250
251 //rv = outCh->OpenOutputStream(0, -1, 0, getter_AddRefs(outStr));
252 //if (NS_FAILED(rv)) return rv;
253
254 // Copy from one to the other
255 rv = Copy(inStr, outStr, mBuffer, mBufferSize, &copyCount);
256 if (NS_FAILED(rv)) return rv;
257
258 endTime = PR_IntervalNow();
259 gTimeSampler.AddTime(endTime - startTime);
260
261 return rv;
262 }
263
264 NS_DECL_ISUPPORTS
265
266 FileChannelWorker()
267 : mInPath(nullptr), mOutPath(nullptr), mBuffer(nullptr),
268 mBufferSize(0)
269 {
270 }
271
272 nsresult Init(nsIFile* inPath, nsIFile* outPath,
273 uint32_t bufferSize)
274 {
275 mInPath = inPath;
276 mOutPath = outPath;
277 mBuffer = new char[bufferSize];
278 mBufferSize = bufferSize;
279 return (mInPath && mOutPath && mBuffer)
280 ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
281 }
282
283 static nsresult Create(nsIRunnable* *result,
284 nsIFile* inPath,
285 nsIFile* outPath,
286 uint32_t bufferSize)
287 {
288 FileChannelWorker* worker = new FileChannelWorker();
289 if (worker == nullptr)
290 return NS_ERROR_OUT_OF_MEMORY;
291 NS_ADDREF(worker);
292
293 nsresult rv = worker->Init(inPath, outPath, bufferSize);
294 if (NS_FAILED(rv)) {
295 NS_RELEASE(worker);
296 return rv;
297 }
298 *result = worker;
299 return NS_OK;
300 }
301
302 virtual ~FileChannelWorker() {
303 delete[] mBuffer;
304 }
305
306 protected:
307 nsCOMPtr<nsIFile> mInPath;
308 nsCOMPtr<nsIFile> mOutPath;
309 char* mBuffer;
310 uint32_t mBufferSize;
311 };
312
313 NS_IMPL_ISUPPORTS(FileChannelWorker, nsIRunnable)
314
315 ////////////////////////////////////////////////////////////////////////////////
316
317 void
318 Test(CreateFun create, uint32_t count,
319 nsIFile* inDirSpec, nsIFile* outDirSpec, uint32_t bufSize)
320 {
321 nsresult rv;
322 uint32_t i;
323
324 nsAutoCString inDir;
325 nsAutoCString outDir;
326 (void)inDirSpec->GetNativePath(inDir);
327 (void)outDirSpec->GetNativePath(outDir);
328 printf("###########\nTest: from %s to %s, bufSize = %d\n",
329 inDir.get(), outDir.get(), bufSize);
330 gTimeSampler.Reset();
331 nsTimeSampler testTime;
332 testTime.StartTime();
333
334 nsCOMArray<nsIThread> threads;
335
336 nsCOMPtr<nsISimpleEnumerator> entries;
337 rv = inDirSpec->GetDirectoryEntries(getter_AddRefs(entries));
338 NS_ASSERTION(NS_SUCCEEDED(rv), "GetDirectoryEntries failed");
339
340 i = 0;
341 bool hasMore;
342 while (i < count && NS_SUCCEEDED(entries->HasMoreElements(&hasMore)) && hasMore) {
343 nsCOMPtr<nsISupports> next;
344 rv = entries->GetNext(getter_AddRefs(next));
345 if (NS_FAILED(rv)) goto done;
346
347 nsCOMPtr<nsIFile> inSpec = do_QueryInterface(next, &rv);
348 if (NS_FAILED(rv)) goto done;
349
350 nsCOMPtr<nsIFile> outSpec;
351 rv = outDirSpec->Clone(getter_AddRefs(outSpec)); // don't munge the original
352 if (NS_FAILED(rv)) goto done;
353
354 nsAutoCString leafName;
355 rv = inSpec->GetNativeLeafName(leafName);
356 if (NS_FAILED(rv)) goto done;
357
358 rv = outSpec->AppendNative(leafName);
359 if (NS_FAILED(rv)) goto done;
360
361 bool exists;
362 rv = outSpec->Exists(&exists);
363 if (NS_FAILED(rv)) goto done;
364
365 if (exists) {
366 rv = outSpec->Remove(false);
367 if (NS_FAILED(rv)) goto done;
368 }
369
370 nsCOMPtr<nsIThread> thread;
371 nsCOMPtr<nsIRunnable> worker;
372 rv = create(getter_AddRefs(worker),
373 inSpec,
374 outSpec,
375 bufSize);
376 if (NS_FAILED(rv)) goto done;
377
378 rv = NS_NewThread(getter_AddRefs(thread), worker, 0, PR_JOINABLE_THREAD);
379 if (NS_FAILED(rv)) goto done;
380
381 bool inserted = threads.InsertObjectAt(thread, i);
382 NS_ASSERTION(inserted, "not inserted");
383
384 i++;
385 }
386
387 uint32_t j;
388 for (j = 0; j < i; j++) {
389 nsIThread* thread = threads.ObjectAt(j);
390 thread->Join();
391 }
392
393 done:
394 NS_ASSERTION(rv == NS_OK, "failed");
395
396 testTime.EndTime();
397 char* testStats = testTime.PrintStats();
398 char* workerStats = gTimeSampler.PrintStats();
399 printf(" threads = %d\n work time = %s,\n test time = %s\n",
400 i, workerStats, testStats);
401 PR_smprintf_free(workerStats);
402 PR_smprintf_free(testStats);
403 }
404
405 ////////////////////////////////////////////////////////////////////////////////
406
407 int
408 main(int argc, char* argv[])
409 {
410 nsresult rv;
411
412 if (argc < 2) {
413 printf("usage: %s <in-dir> <out-dir>\n", argv[0]);
414 return -1;
415 }
416 char* inDir = argv[1];
417 char* outDir = argv[2];
418
419 {
420 nsCOMPtr<nsIServiceManager> servMan;
421 NS_InitXPCOM2(getter_AddRefs(servMan), nullptr, nullptr);
422 nsCOMPtr<nsIComponentRegistrar> registrar = do_QueryInterface(servMan);
423 NS_ASSERTION(registrar, "Null nsIComponentRegistrar");
424 if (registrar)
425 registrar->AutoRegister(nullptr);
426
427 nsCOMPtr<nsIFile> inDirFile;
428 rv = NS_NewNativeLocalFile(nsDependentCString(inDir), false, getter_AddRefs(inDirFile));
429 if (NS_FAILED(rv)) return rv;
430
431 nsCOMPtr<nsIFile> outDirFile;
432 rv = NS_NewNativeLocalFile(nsDependentCString(outDir), false, getter_AddRefs(outDirFile));
433 if (NS_FAILED(rv)) return rv;
434
435 CreateFun create = FileChannelWorker::Create;
436 Test(create, 1, inDirFile, outDirFile, 16 * 1024);
437 #if 1
438 printf("FileChannelWorker *****************************\n");
439 Test(create, 20, inDirFile, outDirFile, 16 * 1024);
440 Test(create, 20, inDirFile, outDirFile, 16 * 1024);
441 Test(create, 20, inDirFile, outDirFile, 16 * 1024);
442 Test(create, 20, inDirFile, outDirFile, 16 * 1024);
443 Test(create, 20, inDirFile, outDirFile, 16 * 1024);
444 Test(create, 20, inDirFile, outDirFile, 16 * 1024);
445 Test(create, 20, inDirFile, outDirFile, 16 * 1024);
446 Test(create, 20, inDirFile, outDirFile, 16 * 1024);
447 Test(create, 20, inDirFile, outDirFile, 16 * 1024);
448 #endif
449 create = FileSpecWorker::Create;
450 printf("FileSpecWorker ********************************\n");
451 #if 1
452 Test(create, 20, inDirFile, outDirFile, 16 * 1024);
453 Test(create, 20, inDirFile, outDirFile, 16 * 1024);
454 Test(create, 20, inDirFile, outDirFile, 16 * 1024);
455 Test(create, 20, inDirFile, outDirFile, 16 * 1024);
456 Test(create, 20, inDirFile, outDirFile, 16 * 1024);
457 Test(create, 20, inDirFile, outDirFile, 16 * 1024);
458 Test(create, 20, inDirFile, outDirFile, 16 * 1024);
459 Test(create, 20, inDirFile, outDirFile, 16 * 1024);
460 Test(create, 20, inDirFile, outDirFile, 16 * 1024);
461 #endif
462 #if 1
463 Test(create, 20, inDirFile, outDirFile, 4 * 1024);
464 Test(create, 20, inDirFile, outDirFile, 4 * 1024);
465 Test(create, 20, inDirFile, outDirFile, 4 * 1024);
466 Test(create, 20, inDirFile, outDirFile, 4 * 1024);
467 Test(create, 20, inDirFile, outDirFile, 4 * 1024);
468 Test(create, 20, inDirFile, outDirFile, 4 * 1024);
469 Test(create, 20, inDirFile, outDirFile, 4 * 1024);
470 Test(create, 20, inDirFile, outDirFile, 4 * 1024);
471 Test(create, 20, inDirFile, outDirFile, 4 * 1024);
472 #endif
473 } // this scopes the nsCOMPtrs
474 // no nsCOMPtrs are allowed to be alive when you call NS_ShutdownXPCOM
475 rv = NS_ShutdownXPCOM(nullptr);
476 NS_ASSERTION(NS_SUCCEEDED(rv), "NS_ShutdownXPCOM failed");
477 return 0;
478 }
479
480 ////////////////////////////////////////////////////////////////////////////////

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial