← Back to branch summary

~ubuntu-branches/ubuntu/karmic/gnustep-base/karmic

« back to all changes in this revision

Viewing changes to Testing/benchmark.m

  • Committer: Bazaar Package Importer
  • Author(s): Eric Heintzmann
  • Date: 2005-04-17 00:14:38 UTC
  • mfrom: (1.2.1 upstream) (2.1.2 hoary)
  • Revision ID: james.westby@ubuntu.com-20050417001438-enf0y07c9tku85z1
Tags: 1.10.3-1
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
Testing/benchmark.m
76
76
  START_TIMER;
77
77
  for (i = 0; i < MAX_COUNT*10; i++)
78
78
    {
79
 
      id i = [rootClass class];
 
79
      [rootClass class];
80
80
    }
81
81
  END_TIMER;
82
82
  baseline = [eTime timeIntervalSinceDate: sTime];
83
 
  PRINT_TIMER("Baseline: 10 method calls");
 
83
  PRINT_TIMER("Baseline: 10 method calls\t\t");
84
84
 
85
85
  START_TIMER;
86
86
  for (i = 0; i < MAX_COUNT; i++)
99
99
      i = [NSMutableDictionary class];
100
100
    }
101
101
  END_TIMER;
102
 
  PRINT_TIMER("Class: 10 class method calls");
103
 
  
 
102
  PRINT_TIMER("Class: 10 class method calls\t\t");
 
103
 
104
104
  obj = [MyObject new];
105
 
  
 
105
 
106
106
  START_TIMER;
107
107
  for (i = 0; i < MAX_COUNT * 10; i++)
108
108
    {
110
110
      i = [obj self];
111
111
    }
112
112
  END_TIMER;
113
 
  PRINT_TIMER_NO_BASELINE("Category: 10 super calls");
114
 
  
 
113
  PRINT_TIMER_NO_BASELINE("Category: 10 super calls\t\t");
 
114
 
115
115
  START_TIMER;
116
116
  for (i = 0; i < MAX_COUNT; i++)
117
117
    {
129
129
      i = NSClassFromString (@"NSMutableDictionary");
130
130
    }
131
131
  END_TIMER;
132
 
  PRINT_TIMER("Function: 10 NSClassFromStr");
133
 
 
134
 
  START_TIMER;
135
 
  myZone = NSCreateZone(2048, 2048, 1);
136
 
  for (i = 0; i < MAX_COUNT; i++)
137
 
    {
138
 
      void      *mem = NSZoneMalloc(myZone, 32);
139
 
      NSZoneFree(myZone, mem);
140
 
    }
141
 
  NSRecycleZone(myZone);
142
 
  END_TIMER;
143
 
  PRINT_TIMER("Function: 1 zone alloc/free");
144
 
 
145
 
  START_TIMER;
146
 
  myZone = NSCreateZone(2048, 2048, 0);
147
 
  for (i = 0; i < MAX_COUNT; i++)
148
 
    {
149
 
      void      *mem = NSZoneMalloc(myZone, 32);
150
 
      NSZoneFree(myZone, mem);
151
 
    }
152
 
  NSRecycleZone(myZone);
153
 
  END_TIMER;
154
 
  PRINT_TIMER("Function: 1 zone2alloc/free");
155
 
 
156
 
  myZone = NSDefaultMallocZone();
157
 
  START_TIMER;
158
 
  for (i = 0; i < MAX_COUNT; i++)
159
 
    {
160
 
      void      *mem = NSZoneMalloc(myZone, 32);
161
 
      NSZoneFree(myZone, mem);
162
 
    }
163
 
  END_TIMER;
164
 
  PRINT_TIMER("Function: 1 def alloc/free");
165
 
 
166
 
  START_TIMER;
167
 
  myZone = NSCreateZone(2048, 2048, 1);
168
 
  for (i = 0; i < MAX_COUNT; i++)
169
 
    {
170
 
      obj = [[rootClass allocWithZone: myZone] init];
171
 
      [obj release];
172
 
    }
173
 
  NSRecycleZone(myZone);
174
 
  END_TIMER;
175
 
  PRINT_TIMER("NSObject: 1 zone all/init/rel");
176
 
 
177
 
  START_TIMER;
178
 
  myZone = NSCreateZone(2048, 2048, 0);
179
 
  for (i = 0; i < MAX_COUNT; i++)
180
 
    {
181
 
      obj = [[rootClass allocWithZone: myZone] init];
182
 
      [obj release];
183
 
    }
184
 
  NSRecycleZone(myZone);
185
 
  END_TIMER;
186
 
  PRINT_TIMER("NSObject: 1 zone2all/init/rel");
187
 
 
188
 
  myZone = NSDefaultMallocZone();
189
 
  START_TIMER;
190
 
  for (i = 0; i < MAX_COUNT; i++)
191
 
    {
192
 
      obj = [[rootClass allocWithZone: myZone] init];
193
 
      [obj release];
194
 
    }
195
 
  END_TIMER;
196
 
  PRINT_TIMER("NSObject: 1 def all/init/rel");
 
132
  PRINT_TIMER("Function: 10 NSClassFromStr\t\t");
 
133
 
 
134
  START_TIMER;
 
135
  myZone = NSCreateZone(2048, 2048, 1);
 
136
  for (i = 0; i < MAX_COUNT; i++)
 
137
    {
 
138
      void      *mem = NSZoneMalloc(myZone, 32);
 
139
      NSZoneFree(myZone, mem);
 
140
    }
 
141
  NSRecycleZone(myZone);
 
142
  END_TIMER;
 
143
  PRINT_TIMER("Function: 1 zone alloc/free\t\t");
 
144
 
 
145
  START_TIMER;
 
146
  myZone = NSCreateZone(2048, 2048, 0);
 
147
  for (i = 0; i < MAX_COUNT; i++)
 
148
    {
 
149
      void      *mem = NSZoneMalloc(myZone, 32);
 
150
      NSZoneFree(myZone, mem);
 
151
    }
 
152
  NSRecycleZone(myZone);
 
153
  END_TIMER;
 
154
  PRINT_TIMER("Function: 1 zone2alloc/free\t\t");
 
155
 
 
156
  myZone = NSDefaultMallocZone();
 
157
  START_TIMER;
 
158
  for (i = 0; i < MAX_COUNT; i++)
 
159
    {
 
160
      void      *mem = NSZoneMalloc(myZone, 32);
 
161
      NSZoneFree(myZone, mem);
 
162
    }
 
163
  END_TIMER;
 
164
  PRINT_TIMER("Function: 1 def alloc/free\t\t");
 
165
 
 
166
  START_TIMER;
 
167
  myZone = NSCreateZone(2048, 2048, 1);
 
168
  for (i = 0; i < MAX_COUNT; i++)
 
169
    {
 
170
      obj = [[rootClass allocWithZone: myZone] init];
 
171
      [obj release];
 
172
    }
 
173
  NSRecycleZone(myZone);
 
174
  END_TIMER;
 
175
  PRINT_TIMER("NSObject: 1 zone all/init/rel\t\t");
 
176
 
 
177
  START_TIMER;
 
178
  myZone = NSCreateZone(2048, 2048, 0);
 
179
  for (i = 0; i < MAX_COUNT; i++)
 
180
    {
 
181
      obj = [[rootClass allocWithZone: myZone] init];
 
182
      [obj release];
 
183
    }
 
184
  NSRecycleZone(myZone);
 
185
  END_TIMER;
 
186
  PRINT_TIMER("NSObject: 1 zone2all/init/rel\t\t");
 
187
 
 
188
  myZone = NSDefaultMallocZone();
 
189
  START_TIMER;
 
190
  for (i = 0; i < MAX_COUNT; i++)
 
191
    {
 
192
      obj = [[rootClass allocWithZone: myZone] init];
 
193
      [obj release];
 
194
    }
 
195
  END_TIMER;
 
196
  PRINT_TIMER("NSObject: 1 def all/init/rel\t\t");
197
197
 
198
198
  obj = [rootClass new];
199
199
  START_TIMER;
203
203
      [obj release];
204
204
    }
205
205
  END_TIMER;
206
 
  PRINT_TIMER("NSObject: 10 retain/rel");
 
206
  PRINT_TIMER("NSObject: 10 retain/rel\t\t");
207
207
  [obj release];
208
208
 
209
209
  obj = [rootClass new];
214
214
      [obj retain];
215
215
    }
216
216
  END_TIMER;
217
 
  PRINT_TIMER("NSObject: 10 autorel/ret");
 
217
  PRINT_TIMER("NSObject: 10 autorel/ret\t\t");
218
218
  [obj release];
219
219
 
220
220
  START_TIMER;
221
221
  for (i = 0; i < MAX_COUNT*10; i++)
222
222
    {
223
 
      BOOL dummy = [rootClass instancesRespondToSelector: @selector(hash)];
 
223
      [rootClass instancesRespondToSelector: @selector(hash)];
224
224
    }
225
225
  END_TIMER;
226
 
  PRINT_TIMER("ObjC: 10 inst responds to sel");
 
226
  PRINT_TIMER("ObjC: 10 inst responds to sel\t\t");
227
227
 
228
228
  mutex = objc_mutex_allocate();
229
229
  START_TIMER;
233
233
      objc_mutex_unlock(mutex);
234
234
    }
235
235
  END_TIMER;
236
 
  PRINT_TIMER("ObjC: 10 objc_mutex_lock/unl");
 
236
  PRINT_TIMER("ObjC: 10 objc_mutex_lock/unl\t\t");
237
237
  objc_mutex_deallocate(mutex);
238
238
 
239
239
  obj = [NSLock new];
244
244
      [obj unlock];
245
245
    }
246
246
  END_TIMER;
247
 
  PRINT_TIMER("NSLock: 10 lock/unlock");
 
247
  PRINT_TIMER("NSLock: 10 lock/unlock\t\t");
248
248
  [obj release];
249
249
 
250
250
 
257
257
  int i;
258
258
  id array;
259
259
  NSString      *strings[MAX_COUNT];
260
 
 
 
260
 
261
261
  AUTO_START;
262
262
  for (i = 0; i < MAX_COUNT; i++)
263
263
    {
273
273
      [array addObject: strings[i/10]];
274
274
    }
275
275
  END_TIMER;
276
 
  PRINT_TIMER("NSArray (10 addObject:)");
 
276
  PRINT_TIMER("NSArray (10 addObject:)\t\t");
277
277
 
278
278
  START_TIMER;
279
279
  for (i = 0; i < MAX_COUNT/100; i++)
281
281
      [array indexOfObject: strings[i]];
282
282
    }
283
283
  END_TIMER;
284
 
  PRINT_TIMER("NSArray (1/100 indexOfObj)");
 
284
  PRINT_TIMER("NSArray (1/100 indexOfObj)\t\t");
285
285
 
286
286
  START_TIMER;
287
287
  for (i = 0; i < MAX_COUNT/100; i++)
289
289
      [array indexOfObjectIdenticalTo: strings[i]];
290
290
    }
291
291
  END_TIMER;
292
 
  PRINT_TIMER("NSArray (1/100 indexIdent)");
 
292
  PRINT_TIMER("NSArray (1/100 indexIdent)\t\t");
293
293
 
294
294
  START_TIMER;
295
295
  for (i = 0; i < 1; i++)
297
297
      [array makeObjectsPerformSelector: @selector(hash)];
298
298
    }
299
299
  END_TIMER;
300
 
  PRINT_TIMER("NSArray (once perform)");
 
300
  PRINT_TIMER("NSArray (once perform)\t\t");
301
301
  AUTO_END;
302
302
}
303
303
 
309
309
  id obj2;
310
310
  NSString      *keys[MAX_COUNT/10];
311
311
  NSString      *vals[MAX_COUNT/10];
312
 
 
 
312
 
313
313
  AUTO_START;
314
314
  for (i = 0; i < MAX_COUNT/10; i++)
315
315
    {
332
332
        }
333
333
    }
334
334
  END_TIMER;
335
 
  PRINT_TIMER("NSDict (1 setObject:) ");
 
335
  PRINT_TIMER("NSDict (1 setObject:) \t\t");
336
336
 
337
337
  START_TIMER;
338
338
  for (i = 0; i < MAX_COUNT; i++)
341
341
 
342
342
      for (j = 0; j < 10; j++)
343
343
        {
344
 
          id dummy = [dict objectForKey: keys[i/10]];
 
344
          [dict objectForKey: keys[i/10]];
345
345
        }
346
346
    }
347
347
  END_TIMER;
348
 
  PRINT_TIMER("NSDict (10 objectFor:) ");
 
348
  PRINT_TIMER("NSDict (10 objectFor:) \t\t");
349
349
 
350
350
  START_TIMER;
351
351
  for (i = 0; i < MAX_COUNT*10; i++)
352
352
    {
353
 
      int dummy = [dict count];
 
353
      [dict count];
354
354
    }
355
355
  END_TIMER;
356
 
  PRINT_TIMER("NSDictionary (10 count)");
 
356
  PRINT_TIMER("NSDictionary (10 count)\t\t");
357
357
 
358
358
  obj2 = [dict copy];
359
359
  START_TIMER;
360
360
  for (i = 0; i < 10; i++)
361
361
    {
362
 
      BOOL dummy = [dict isEqual: obj2];
 
362
      [dict isEqual: obj2];
363
363
    }
364
364
  END_TIMER;
365
 
  PRINT_TIMER("NSDict (ten times isEqual:)");
 
365
  PRINT_TIMER("NSDict (ten times isEqual:)\t\t");
366
366
  AUTO_END;
367
367
}
368
368
 
371
371
{
372
372
  int i;
373
373
  NSString *str;
 
374
  NSMutableString       *ms;
374
375
  id plist;
375
376
  NSString *plstr;
376
377
  Class arc = [NSArchiver class];
378
379
  Class ser = [NSSerializer class];
379
380
  Class des = [NSDeserializer class];
380
381
  Class md = [NSMutableDictionary class];
381
 
 
382
382
  AUTO_START;
383
383
 
 
384
  [[md new] release];
 
385
 
384
386
  plist = [NSDictionary dictionaryWithObjectsAndKeys:
385
387
        @"Value1", @"Key1",
386
388
        @"", @"Key2",
405
407
        [NSData dataWithBytes: "hello" length: 5], @"Key8",
406
408
        nil];
407
409
  plstr = [plist description];
408
 
 
 
410
 
409
411
  printf("NSString\n");
 
412
 
 
413
  START_TIMER;
 
414
  for (i = 0; i < MAX_COUNT; i++)
 
415
    {
 
416
      str = [[stringClass alloc] initWithFormat: @"Hello %d", i];
 
417
      RELEASE(str);
 
418
    }
 
419
  END_TIMER;
 
420
  PRINT_TIMER("NSString (1 initWithFormat:) \t");
 
421
 
 
422
  ms = [NSMutableString stringWithCapacity: 0];
 
423
  START_TIMER;
 
424
  for (i = 0; i < MAX_COUNT; i++)
 
425
    {
 
426
      [ms appendFormat: @"%d", i];
 
427
    }
 
428
  END_TIMER;
 
429
  PRINT_TIMER("NSString (1 appendFormat:) \t\t");
 
430
 
410
431
  START_TIMER;
411
432
  for (i = 0; i < MAX_COUNT; i++)
412
433
    {
413
434
      str = [stringClass stringWithCString: "hello world"];
414
435
    }
415
436
  END_TIMER;
416
 
  PRINT_TIMER("NSString (1 cstring:) ");
417
 
 
418
 
  START_TIMER;
419
 
  for (i = 0; i < MAX_COUNT*10; i++)
420
 
    {
421
 
      int dummy = [str length];
422
 
    }
423
 
  END_TIMER;
424
 
  PRINT_TIMER("NSString (10 length)   ");
 
437
  PRINT_TIMER("NSString (1 cstring:) \t\t");
 
438
 
 
439
  START_TIMER;
 
440
  for (i = 0; i < MAX_COUNT*10; i++)
 
441
    {
 
442
      [str length];
 
443
    }
 
444
  END_TIMER;
 
445
  PRINT_TIMER("NSString (10 length)   \t\t");
 
446
 
 
447
  START_TIMER;
 
448
  for (i = 0; i < MAX_COUNT*10; i++)
 
449
    {
 
450
      [str copy];
 
451
    }
 
452
  END_TIMER;
 
453
  PRINT_TIMER("NSString (10 copy) <initWithCString:>   ");
 
454
 
 
455
  str = @"ConstantString";
 
456
  START_TIMER;
 
457
  for (i = 0; i < MAX_COUNT*10; i++)
 
458
    {
 
459
      [str copy];
 
460
    }
 
461
  END_TIMER;
 
462
  PRINT_TIMER("NSString (10 copy) <@'ConstantString'>   ");
 
463
 
 
464
  str = [[NSString alloc] initWithCStringNoCopy: (char *)[str cString]
 
465
                          length: [str length]
 
466
                          freeWhenDone: NO];
 
467
  START_TIMER;
 
468
  for (i = 0; i < MAX_COUNT*10; i++)
 
469
    {
 
470
      [str copy];
 
471
    }
 
472
  END_TIMER;
 
473
  PRINT_TIMER("NSString (10 copy) <NoCopy:free:NO>   ");
 
474
 
 
475
  str = [[NSString alloc] initWithCStringNoCopy: (char *)[str cString]
 
476
                          length: [str length]
 
477
                          freeWhenDone: YES];
 
478
  START_TIMER;
 
479
  for (i = 0; i < MAX_COUNT*10; i++)
 
480
    {
 
481
      [str copy];
 
482
    }
 
483
  END_TIMER;
 
484
  PRINT_TIMER("NSString (10 copy) <NoCopy:free:YES>   ");
 
485
 
 
486
  str = [stringClass stringWithCString: "hello world"];
 
487
  START_TIMER;
 
488
  for (i = 0; i < MAX_COUNT*10; i++)
 
489
    {
 
490
      [str hash];
 
491
    }
 
492
  END_TIMER;
 
493
  PRINT_TIMER("NSString (10 hash) <initWithCString:>   ");
 
494
 
 
495
  str = @"ConstantString";
 
496
  START_TIMER;
 
497
  for (i = 0; i < MAX_COUNT*10; i++)
 
498
    {
 
499
      [str hash];
 
500
    }
 
501
  END_TIMER;
 
502
  PRINT_TIMER("NSString (10 hash) <@'ConstantString'>   ");
425
503
 
426
504
  START_TIMER;
427
505
  for (i = 0; i < MAX_COUNT/100; i++)
428
506
    {
429
507
      id arp = [NSAutoreleasePool new];
430
 
      NSString  *s = [plist description];
 
508
      [plist description];
431
509
      [arp release];
432
510
    }
433
511
  END_TIMER;
434
 
  PRINT_TIMER("NSString (1/100 mkplist) ");
 
512
  PRINT_TIMER("NSString (1/100 mkplist) \t\t");
435
513
 
436
514
  START_TIMER;
437
515
  for (i = 0; i < MAX_COUNT/1000; i++)
438
516
    {
439
 
      id p = [plstr propertyList];
 
517
      [plstr propertyList];
440
518
    }
441
519
  END_TIMER;
442
 
  PRINT_TIMER("NSString (1/1000 plparse)");
 
520
  PRINT_TIMER("NSString (1/1000 plparse)\t\t");
443
521
 
444
522
  START_TIMER;
445
523
  for (i = 0; i < MAX_COUNT/1000; i++)
454
532
      [arp release];
455
533
    }
456
534
  END_TIMER;
457
 
  PRINT_TIMER("NSString (1/1000 plcomp)");
 
535
  PRINT_TIMER("NSString (1/1000 plcomp)\t\t");
458
536
 
459
537
  START_TIMER;
460
538
  for (i = 0; i < MAX_COUNT/100; i++)
461
539
    {
462
540
      NSData    *d = [ser serializePropertyList: plist];
463
 
      id        p = [des deserializePropertyListFromData: d
464
 
                                       mutableContainers: NO];
 
541
      [des deserializePropertyListFromData: d mutableContainers: NO];
465
542
    }
466
543
  END_TIMER;
467
 
  PRINT_TIMER("NSString (1/100 ser/des)");
 
544
  PRINT_TIMER("NSString (1/100 ser/des)\t\t");
468
545
 
469
546
  [NSDeserializer uniquing: YES];
470
547
  START_TIMER;
471
548
  for (i = 0; i < MAX_COUNT/100; i++)
472
549
    {
473
550
      NSData    *d = [ser serializePropertyList: plist];
474
 
      id        p = [des deserializePropertyListFromData: d
475
 
                                       mutableContainers: NO];
 
551
      [des deserializePropertyListFromData: d mutableContainers: NO];
476
552
    }
477
553
  END_TIMER;
478
 
  PRINT_TIMER("NSString (1/100 ser/des - uniquing)");
 
554
  PRINT_TIMER("NSString (1/100 ser/des - uniquing)\t");
479
555
  [NSDeserializer uniquing: NO];
480
556
 
481
557
  START_TIMER;
482
558
  for (i = 0; i < MAX_COUNT/100; i++)
483
559
    {
484
560
      NSData    *d = [arc archivedDataWithRootObject: plist];
485
 
      id        p = [una unarchiveObjectWithData: d];
486
 
    }
487
 
  END_TIMER;
488
 
  PRINT_TIMER("NSString (1/100 arc/una)");
489
 
 
 
561
      [una unarchiveObjectWithData: d];
 
562
    }
 
563
  END_TIMER;
 
564
  PRINT_TIMER("NSString (1/100 arc/una)\t\t");
 
565
 
 
566
  AUTO_END;
 
567
}
 
568
 
 
569
void
 
570
bench_date()
 
571
{
 
572
  int i;
 
573
  id d;
 
574
  AUTO_START;
 
575
  Class dateClass = [NSCalendarDate class];
 
576
 
 
577
  printf("NSCalendarDate\n");
 
578
  START_TIMER;
 
579
  for (i = 0; i < MAX_COUNT/10; i++)
 
580
    {
 
581
      d = [[dateClass alloc] init];
 
582
      [d description];
 
583
      [d dayOfYear];
 
584
      [d minuteOfHour];
 
585
      [d release];
 
586
    }
 
587
  END_TIMER;
 
588
  PRINT_TIMER("NSCalendarDate (various)\t\t");
490
589
  AUTO_END;
491
590
}
492
591
 
501
600
  printf("NSData\n");
502
601
  START_TIMER;
503
602
  for (i = 0; i < MAX_COUNT/10; i++)
504
 
    { 
 
603
    {
505
604
      d = [[dataClass alloc] initWithContentsOfFile:@"benchmark.m"];
506
605
      [d length];
507
606
      o = [d copy];
511
610
      [d release];
512
611
    }
513
612
  END_TIMER;
514
 
  PRINT_TIMER("NSData (various)");
 
613
  PRINT_TIMER("NSData (various)\t\t\t");
515
614
  AUTO_END;
516
615
}
517
616
 
524
623
#endif
525
624
 
526
625
  /*
527
 
   *    Cache classes to remove overhead of objc runtime class lookup from 
 
626
   *    Cache classes to remove overhead of objc runtime class lookup from
528
627
   *    the benchmark.
529
628
   */
530
629
  rootClass = [NSObject class];
531
630
  stringClass = [NSString class];
532
 
 
 
631
 
533
632
  pool = [NSAutoreleasePool new];
534
 
  printf(" Test                 \t time (sec) \t index\n");
 
633
  printf(" Test                 \t\t\t\t time (sec) \t index\n");
535
634
  bench_object();
536
635
  bench_str();
537
636
  bench_array();
538
637
  bench_dict();
 
638
  bench_date();
539
639
  bench_data();
540
640
  AUTO_END;
541
641
  return 0;