TAO/performance-tests/Anyop/anyop.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file   anyop.cpp
   5  *
   6  * Modified from anyop.cpp in Param_Test to benchmark Any insertion and
   7  * extraction operators for various IDL types.
   8  *
   9  *  @author Carlos O'Ryan Jeff Parsons
  10  */
  11 //=============================================================================
  12
  13
  14 #include "testC.h"
  15 #include "tao/debug.h"
  16 #include "tao/AnyTypeCode/Any.h"
  17 #include "tao/Stub.h"
  18 #include "tao/Object_T.h"
  19 #include "ace/Get_Opt.h"
  20 #include "ace/High_Res_Timer.h"
  21 #include "ace/Stats.h"
  22 #include "ace/Throughput_Stats.h"
  23 #include "ace/Sample_History.h"
  24 #include "ace/Sched_Params.h"
  25
  26 int
  27 ACE_TMAIN (int argc, ACE_TCHAR *argv[])
  28 {
  29   int priority =
  30     (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO)
  31      + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2;
  32
  33   ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO,
  34                                           priority,
  35                                           ACE_SCOPE_PROCESS));
  36
  37   int n = 50000;
  38   int insertion = 1;
  39
  40   try
  41     {
  42       CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
  43
  44       ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("dien:"));
  45       int opt;
  46
  47       while ((opt = get_opt ()) != EOF)
  48         {
  49           switch (opt)
  50             {
  51             case 'd':
  52               TAO_debug_level++;
  53               break;
  54             case 'i':
  55               insertion = 1;
  56               break;
  57             case 'e':
  58               insertion = 0;
  59               break;
  60             case 'n':
  61               n = ACE_OS::atoi (get_opt.opt_arg ());
  62               break;
  63             case '?':
  64             default:
  65               ACE_DEBUG ((LM_DEBUG,
  66                           "Usage: %s "
  67                           "-d debug"
  68                           "-n <num> "
  69                           "\n",
  70                           argv[0]));
  71               return -1;
  72             }
  73         }
  74
  75       CORBA::Boolean result = 0;
  76       int j;
  77
  78       {
  79         CORBA::Object_var obj =
  80           orb->string_to_object ("corbaloc:iiop:localhost:1234/Foo/Bar");
  81
  82         Param_Test_var param_test =
  83           TAO::Narrow_Utils<Param_Test>::unchecked_narrow (obj.in ());
  84         TAO_Stub *stub = param_test->_stubobj ();
  85         stub->type_id = CORBA::string_dup ("IDL:Param_Test:1.0");
  86
  87         ACE_Sample_History history (n);
  88         ACE_hrtime_t test_start = ACE_OS::gethrtime ();
  89
  90         for (j = 0; j != n; ++j)
  91           {
  92             CORBA::Any any;
  93
  94             if (insertion == 1)
  95               {
  96                 ACE_hrtime_t start = ACE_OS::gethrtime ();
  97
  98                 any <<= param_test.in ();
  99
 100                 ACE_hrtime_t now = ACE_OS::gethrtime ();
 101                 history.sample (now - start);
 102
 103                 Param_Test_ptr o;
 104
 105                 result = any >>= o;
 106               }
 107             else
 108               {
 109                 any <<= param_test.in ();
 110
 111                 Param_Test_ptr o;
 112
 113                 ACE_hrtime_t start = ACE_OS::gethrtime ();
 114
 115                 result = any >>= o;
 116
 117                 ACE_hrtime_t now = ACE_OS::gethrtime ();
 118                 history.sample (now - start);
 119               }
 120           }
 121
 122         ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 123
 124         if (insertion == 1)
 125           {
 126             ACE_DEBUG ((LM_DEBUG,
 127                         "Objref insertion test finished\n"));
 128           }
 129         else
 130           {
 131             ACE_DEBUG ((LM_DEBUG,
 132                         "Objref extraction test finished\n"));
 133           }
 134
 135         ACE_DEBUG ((LM_DEBUG,
 136                     "High resolution timer calibration...."));
 137         ACE_High_Res_Timer::global_scale_factor_type gsf =
 138           ACE_High_Res_Timer::global_scale_factor ();
 139         ACE_DEBUG ((LM_DEBUG,
 140                     "done\n"));
 141
 142         ACE_Basic_Stats stats;
 143         history.collect_basic_stats (stats);
 144         stats.dump_results (ACE_TEXT("Total"), gsf);
 145
 146         ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"),
 147                                                gsf,
 148                                                test_end - test_start,
 149                                                stats.samples_count ());
 150       }
 151
 152       ACE_DEBUG ((LM_DEBUG, "\n"));
 153
 154       {
 155         ACE_Sample_History history (n);
 156         ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 157
 158         for (j = 0; j != n; ++j)
 159           {
 160             CORBA::Any any;
 161             CORBA::Short i = 123;
 162
 163             if (insertion == 1)
 164               {
 165                 ACE_hrtime_t start = ACE_OS::gethrtime ();
 166
 167                 any <<= i;
 168
 169                 ACE_hrtime_t now = ACE_OS::gethrtime ();
 170                 history.sample (now - start);
 171
 172                 CORBA::Short o;
 173
 174                 result = any >>= o;
 175                   }
 176                 else
 177               {
 178                 any <<= i;
 179
 180                 CORBA::Short o;
 181
 182                 ACE_hrtime_t start = ACE_OS::gethrtime ();
 183
 184                 result = any >>= o;
 185
 186                 ACE_hrtime_t now = ACE_OS::gethrtime ();
 187                 history.sample (now - start);
 188               }
 189           }
 190
 191         ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 192
 193         if (insertion == 1)
 194           {
 195             ACE_DEBUG ((LM_DEBUG,
 196                         "Short insertion test finished\n"));
 197           }
 198         else
 199           {
 200             ACE_DEBUG ((LM_DEBUG,
 201                         "Short extraction test finished\n"));
 202           }
 203         ACE_DEBUG ((LM_DEBUG,
 204                     "High resolution timer calibration...."));
 205         ACE_High_Res_Timer::global_scale_factor_type gsf =
 206           ACE_High_Res_Timer::global_scale_factor ();
 207         ACE_DEBUG ((LM_DEBUG,
 208                     "done\n"));
 209
 210         ACE_Basic_Stats stats;
 211         history.collect_basic_stats (stats);
 212         stats.dump_results (ACE_TEXT("Total"), gsf);
 213
 214         ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"),
 215                                                gsf,
 216                                                test_end - test_start,
 217                                                stats.samples_count ());
 218       }
 219
 220       ACE_DEBUG ((LM_DEBUG, "\n"));
 221
 222       {
 223         ACE_Sample_History history (n);
 224         ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 225
 226         for (j = 0; j != n; ++j)
 227           {
 228             CORBA::Any any;
 229             CORBA::Long i = 123;
 230
 231             if (insertion == 1)
 232               {
 233                 ACE_hrtime_t start = ACE_OS::gethrtime ();
 234
 235                 any <<= i;
 236
 237                 ACE_hrtime_t now = ACE_OS::gethrtime ();
 238                 history.sample (now - start);
 239
 240                 CORBA::Long o;
 241
 242                 result = any >>= o;
 243               }
 244             else
 245               {
 246                 any <<= i;
 247
 248                 CORBA::Long o;
 249
 250                 ACE_hrtime_t start = ACE_OS::gethrtime ();
 251
 252                 result = any >>= o;
 253
 254                 ACE_hrtime_t now = ACE_OS::gethrtime ();
 255                 history.sample (now - start);
 256               }
 257           }
 258
 259         ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 260
 261         if (insertion == 1)
 262           {
 263             ACE_DEBUG ((LM_DEBUG,
 264                         "Long insertion test finished\n"));
 265           }
 266         else
 267           {
 268             ACE_DEBUG ((LM_DEBUG,
 269                         "Long extraction test finished\n"));
 270           }
 271
 272         ACE_DEBUG ((LM_DEBUG,
 273                     "High resolution timer calibration...."));
 274         ACE_High_Res_Timer::global_scale_factor_type gsf =
 275           ACE_High_Res_Timer::global_scale_factor ();
 276         ACE_DEBUG ((LM_DEBUG,
 277                     "done\n"));
 278
 279         ACE_Basic_Stats stats;
 280         history.collect_basic_stats (stats);
 281         stats.dump_results (ACE_TEXT("Total"), gsf);
 282
 283         ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"),
 284                                                gsf,
 285                                                test_end - test_start,
 286                                                stats.samples_count ());
 287       }
 288
 289       ACE_DEBUG ((LM_DEBUG, "\n"));
 290
 291       {
 292         ACE_Sample_History history (n);
 293         ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 294
 295         for (j = 0; j != n; ++j)
 296           {
 297             CORBA::Any any;
 298             CORBA::Double i = 123;
 299
 300             if (insertion == 1)
 301               {
 302                 ACE_hrtime_t start = ACE_OS::gethrtime ();
 303
 304                 any <<= i;
 305
 306                 ACE_hrtime_t now = ACE_OS::gethrtime ();
 307                 history.sample (now - start);
 308
 309                 CORBA::Double o;
 310
 311                 result = any >>= o;
 312               }
 313             else
 314               {
 315                 any <<= i;
 316
 317                 CORBA::Double o;
 318
 319                 ACE_hrtime_t start = ACE_OS::gethrtime ();
 320
 321                 result = any >>= o;
 322
 323                 ACE_hrtime_t now = ACE_OS::gethrtime ();
 324                 history.sample (now - start);
 325               }
 326           }
 327
 328         ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 329
 330         if (insertion == 1)
 331           {
 332             ACE_DEBUG ((LM_DEBUG,
 333                         "Double insertion test finished\n"));
 334           }
 335         else
 336           {
 337             ACE_DEBUG ((LM_DEBUG,
 338                         "Double extraction test finished\n"));
 339           }
 340
 341         ACE_DEBUG ((LM_DEBUG,
 342                     "High resolution timer calibration...."));
 343         ACE_High_Res_Timer::global_scale_factor_type gsf =
 344           ACE_High_Res_Timer::global_scale_factor ();
 345         ACE_DEBUG ((LM_DEBUG,
 346                     "done\n"));
 347
 348         ACE_Basic_Stats stats;
 349         history.collect_basic_stats (stats);
 350         stats.dump_results (ACE_TEXT("Total"), gsf);
 351
 352         ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"),
 353                                                gsf,
 354                                                test_end - test_start,
 355                                                stats.samples_count ());
 356       }
 357
 358       ACE_DEBUG ((LM_DEBUG, "\n"));
 359
 360       {
 361         Param_Test::Fixed_Struct i;
 362         i.l = -7;
 363         i.c = 'c';
 364         i.s = 5;
 365         i.o = 255;
 366         i.f = 2.3f;
 367         i.b = 0;
 368         i.d = 3.1416;
 369
 370         ACE_Sample_History history (n);
 371         ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 372
 373         for (j = 0; j != n; ++j)
 374           {
 375             CORBA::Any any;
 376
 377             if (insertion == 1)
 378               {
 379                 ACE_hrtime_t start = ACE_OS::gethrtime ();
 380
 381                 any <<= i;
 382
 383                 ACE_hrtime_t now = ACE_OS::gethrtime ();
 384                 history.sample (now - start);
 385
 386                 const Param_Test::Fixed_Struct *o = 0;
 387
 388                 result = any >>= o;
 389               }
 390             else
 391               {
 392                 any <<= i;
 393
 394                 const Param_Test::Fixed_Struct *o = 0;
 395
 396                 ACE_hrtime_t start = ACE_OS::gethrtime ();
 397
 398                 result = any >>= o;
 399
 400                 ACE_hrtime_t now = ACE_OS::gethrtime ();
 401                 history.sample (now - start);
 402               }
 403           }
 404
 405         ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 406
 407         if (insertion == 1)
 408           {
 409             ACE_DEBUG ((LM_DEBUG,
 410                         "Struct copying insertion test finished\n"));
 411           }
 412         else
 413           {
 414             ACE_DEBUG ((LM_DEBUG,
 415                         "Struct extraction test finished\n"));
 416           }
 417
 418         ACE_DEBUG ((LM_DEBUG,
 419                     "High resolution timer calibration...."));
 420         ACE_High_Res_Timer::global_scale_factor_type gsf =
 421           ACE_High_Res_Timer::global_scale_factor ();
 422         ACE_DEBUG ((LM_DEBUG,
 423                     "done\n"));
 424
 425         ACE_Basic_Stats stats;
 426         history.collect_basic_stats (stats);
 427         stats.dump_results (ACE_TEXT("Total"), gsf);
 428
 429         ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"),
 430                                                gsf,
 431                                                test_end - test_start,
 432                                                stats.samples_count ());
 433       }
 434
 435       ACE_DEBUG ((LM_DEBUG, "\n"));
 436
 437       {
 438         ACE_Sample_History history (n);
 439         ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 440         for (j = 0; j != n; ++j)
 441           {
 442             CORBA::Any any;
 443             Param_Test::Fixed_Struct *i = 0;
 444             ACE_NEW_RETURN (i,
 445                             Param_Test::Fixed_Struct,
 446                             -1);
 447             i->l = -7;
 448             i->c = 'c';
 449             i->s = 5;
 450             i->o = 255;
 451             i->f = 2.3f;
 452             i->b = 0;
 453             i->d = 3.1416;
 454
 455             if (insertion == 1)
 456               {
 457                 ACE_hrtime_t start = ACE_OS::gethrtime ();
 458
 459                 any <<= i;
 460
 461                 ACE_hrtime_t now = ACE_OS::gethrtime ();
 462                 history.sample (now - start);
 463
 464                 const Param_Test::Fixed_Struct *o = 0;
 465
 466                 result = any >>= o;
 467               }
 468             else
 469               {
 470                 any <<= i;
 471
 472                 const Param_Test::Fixed_Struct *o = 0;
 473
 474                 ACE_hrtime_t start = ACE_OS::gethrtime ();
 475
 476                 result = any >>= o;
 477
 478                 ACE_hrtime_t now = ACE_OS::gethrtime ();
 479                 history.sample (now - start);
 480               }
 481           }
 482
 483         ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 484
 485         if (insertion == 1)
 486           {
 487             ACE_DEBUG ((LM_DEBUG,
 488                         "Struct non-copying insertion test finished\n"));
 489           }
 490         else
 491           {
 492             ACE_DEBUG ((LM_DEBUG,
 493                         "Struct extraction test finished\n"));
 494           }
 495
 496         ACE_DEBUG ((LM_DEBUG,
 497                     "High resolution timer calibration...."));
 498         ACE_High_Res_Timer::global_scale_factor_type gsf =
 499           ACE_High_Res_Timer::global_scale_factor ();
 500         ACE_DEBUG ((LM_DEBUG,
 501                     "done\n"));
 502
 503         ACE_Basic_Stats stats;
 504         history.collect_basic_stats (stats);
 505         stats.dump_results (ACE_TEXT("Total"), gsf);
 506
 507         ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"),
 508                                                gsf,
 509                                                test_end - test_start,
 510                                                stats.samples_count ());
 511       }
 512
 513       ACE_DEBUG ((LM_DEBUG, "\n"));
 514
 515       {
 516         CORBA::ULong len = 1024;
 517         Param_Test::Long_Seq i (len);
 518         i.length (len);
 519
 520         for (CORBA::ULong k = 0; k < len; ++k)
 521           {
 522             i[k] = 11;
 523           }
 524
 525         ACE_Sample_History history (n);
 526         ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 527
 528         for (j = 0; j != n; ++j)
 529           {
 530             CORBA::Any any;
 531
 532             if (insertion == 1)
 533               {
 534                 ACE_hrtime_t start = ACE_OS::gethrtime ();
 535
 536                 any <<= i;
 537
 538                 ACE_hrtime_t now = ACE_OS::gethrtime ();
 539                 history.sample (now - start);
 540
 541                 const Param_Test::Long_Seq *o = 0;
 542
 543                 result = any >>= o;
 544               }
 545             else
 546               {
 547                 any <<= i;
 548
 549                 const Param_Test::Long_Seq *o = 0;
 550
 551                 ACE_hrtime_t start = ACE_OS::gethrtime ();
 552
 553                 result = any >>= o;
 554
 555                 ACE_hrtime_t now = ACE_OS::gethrtime ();
 556                 history.sample (now - start);
 557               }
 558           }
 559
 560         ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 561
 562         if (insertion == 1)
 563           {
 564             ACE_DEBUG ((LM_DEBUG,
 565                         "Sequence copying insertion test finished\n"));
 566           }
 567         else
 568           {
 569             ACE_DEBUG ((LM_DEBUG,
 570                         "Sequence extraction test finished\n"));
 571           }
 572
 573         ACE_DEBUG ((LM_DEBUG,
 574                     "High resolution timer calibration...."));
 575         ACE_High_Res_Timer::global_scale_factor_type gsf =
 576           ACE_High_Res_Timer::global_scale_factor ();
 577         ACE_DEBUG ((LM_DEBUG,
 578                     "done\n"));
 579
 580         ACE_Basic_Stats stats;
 581         history.collect_basic_stats (stats);
 582         stats.dump_results (ACE_TEXT("Total"), gsf);
 583
 584         ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"),
 585                                                gsf,
 586                                                test_end - test_start,
 587                                                stats.samples_count ());
 588       }
 589
 590       ACE_DEBUG ((LM_DEBUG, "\n"));
 591
 592       {
 593         CORBA::ULong len = 1024;
 594         ACE_Sample_History history (n);
 595         ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 596         for (j = 0; j != n; ++j)
 597           {
 598             CORBA::Any any;
 599             Param_Test::Long_Seq *i = 0;
 600             ACE_NEW_RETURN (i,
 601                             Param_Test::Long_Seq (len),
 602                             -1);
 603             i->length (len);
 604
 605             for (CORBA::ULong k = 0; k < len; ++k)
 606               {
 607                 (*i)[k] = 11;
 608               }
 609
 610             if (insertion == 1)
 611               {
 612                 ACE_hrtime_t start = ACE_OS::gethrtime ();
 613
 614                 any <<= i;
 615
 616                 ACE_hrtime_t now = ACE_OS::gethrtime ();
 617                 history.sample (now - start);
 618
 619                 const Param_Test::Long_Seq *o = 0;
 620
 621                 result = any >>= o;
 622               }
 623             else
 624               {
 625                 any <<= i;
 626
 627                 const Param_Test::Long_Seq *o = 0;
 628
 629                 ACE_hrtime_t start = ACE_OS::gethrtime ();
 630
 631                 result = any >>= o;
 632
 633                 ACE_hrtime_t now = ACE_OS::gethrtime ();
 634                 history.sample (now - start);
 635               }
 636           }
 637
 638         ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 639
 640         if (insertion == 1)
 641           {
 642             ACE_DEBUG ((LM_DEBUG,
 643                         "Sequence non-copying insertion test finished\n"));
 644           }
 645         else
 646           {
 647             ACE_DEBUG ((LM_DEBUG,
 648                         "Sequence extraction test finished\n"));
 649           }
 650
 651         ACE_DEBUG ((LM_DEBUG,
 652                     "High resolution timer calibration...."));
 653         ACE_High_Res_Timer::global_scale_factor_type gsf =
 654           ACE_High_Res_Timer::global_scale_factor ();
 655         ACE_DEBUG ((LM_DEBUG,
 656                     "done\n"));
 657
 658         ACE_Basic_Stats stats;
 659         history.collect_basic_stats (stats);
 660         stats.dump_results (ACE_TEXT("Total"), gsf);
 661
 662         ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"),
 663                                                gsf,
 664                                                test_end - test_start,
 665                                                stats.samples_count ());
 666       }
 667
 668       ACE_DEBUG ((LM_DEBUG, "\n"));
 669
 670       {
 671         ACE_Sample_History history (n);
 672         ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 673
 674         for (j = 0; j != n; ++j)
 675           {
 676             CORBA::Any any;
 677             CORBA::Any i;
 678             i <<= CORBA::Short (123);
 679
 680             if (insertion == 1)
 681               {
 682                 ACE_hrtime_t start = ACE_OS::gethrtime ();
 683
 684                 any <<= i;
 685
 686                 ACE_hrtime_t now = ACE_OS::gethrtime ();
 687                 history.sample (now - start);
 688
 689                 const CORBA::Any *o;
 690                 CORBA::Short oo;
 691
 692                 result = any >>= o;
 693                 result = *o >>= oo;
 694               }
 695             else
 696               {
 697                 any <<= i;
 698
 699                 const CORBA::Any *o;
 700                 CORBA::Short oo;
 701
 702                 ACE_hrtime_t start = ACE_OS::gethrtime ();
 703
 704                 result = any >>= o;
 705
 706                 ACE_hrtime_t now = ACE_OS::gethrtime ();
 707                 history.sample (now - start);
 708
 709                 result = *o >>= oo;
 710               }
 711           }
 712
 713         ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 714
 715         if (insertion == 1)
 716           {
 717             ACE_DEBUG ((LM_DEBUG,
 718                         "Any copying insertion test finished\n"));
 719           }
 720         else
 721           {
 722             ACE_DEBUG ((LM_DEBUG,
 723                         "Any extraction test finished\n"));
 724           }
 725
 726         ACE_DEBUG ((LM_DEBUG,
 727                     "High resolution timer calibration...."));
 728         ACE_High_Res_Timer::global_scale_factor_type gsf =
 729           ACE_High_Res_Timer::global_scale_factor ();
 730         ACE_DEBUG ((LM_DEBUG,
 731                     "done\n"));
 732
 733         ACE_Basic_Stats stats;
 734         history.collect_basic_stats (stats);
 735         stats.dump_results (ACE_TEXT("Total"), gsf);
 736
 737         ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"),
 738                                                gsf,
 739                                                test_end - test_start,
 740                                                stats.samples_count ());
 741       }
 742
 743       ACE_DEBUG ((LM_DEBUG, "\n"));
 744
 745       {
 746         ACE_Sample_History history (n);
 747         ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 748
 749         for (j = 0; j != n; ++j)
 750           {
 751             CORBA::Any any;
 752             CORBA::Any *i = 0;
 753             ACE_NEW_RETURN (i,
 754                             CORBA::Any,
 755                             -1);
 756             *i <<= CORBA::Short (123);
 757
 758             if (insertion == 1)
 759               {
 760                 ACE_hrtime_t start = ACE_OS::gethrtime ();
 761
 762                 any <<= i;
 763
 764                 ACE_hrtime_t now = ACE_OS::gethrtime ();
 765                 history.sample (now - start);
 766
 767                 const CORBA::Any *o;
 768                 CORBA::Short oo;
 769
 770                 result = any >>= o;
 771                 result = *o >>= oo;
 772               }
 773             else
 774               {
 775                 any <<= i;
 776
 777                 const CORBA::Any *o;
 778                 CORBA::Short oo;
 779
 780                 ACE_hrtime_t start = ACE_OS::gethrtime ();
 781
 782                 result = any >>= o;
 783
 784                 ACE_hrtime_t now = ACE_OS::gethrtime ();
 785                 history.sample (now - start);
 786
 787                 result = *o >>= oo;
 788               }
 789           }
 790
 791         ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 792
 793         if (insertion == 1)
 794           {
 795             ACE_DEBUG ((LM_DEBUG,
 796                         "Any non-copying insertion test finished\n"));
 797           }
 798         else
 799           {
 800             ACE_DEBUG ((LM_DEBUG,
 801                         "Any extraction test finished\n"));
 802           }
 803
 804         ACE_DEBUG ((LM_DEBUG,
 805                     "High resolution timer calibration...."));
 806         ACE_High_Res_Timer::global_scale_factor_type gsf =
 807           ACE_High_Res_Timer::global_scale_factor ();
 808         ACE_DEBUG ((LM_DEBUG,
 809                     "done\n"));
 810
 811         ACE_Basic_Stats stats;
 812         history.collect_basic_stats (stats);
 813         stats.dump_results (ACE_TEXT("Total"), gsf);
 814
 815         ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"),
 816                                                gsf,
 817                                                test_end - test_start,
 818                                                stats.samples_count ());
 819       }
 820
 821       ACE_DEBUG ((LM_DEBUG, "\n"));
 822
 823       {
 824         ACE_Sample_History history (n);
 825         ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 826
 827         for (j = 0; j != n; ++j)
 828           {
 829             CORBA::Any any;
 830             const char i[] = "1234567890";
 831
 832             if (insertion == 1)
 833               {
 834                 ACE_hrtime_t start = ACE_OS::gethrtime ();
 835
 836                 any <<= i;
 837
 838                 ACE_hrtime_t now = ACE_OS::gethrtime ();
 839                 history.sample (now - start);
 840
 841                 const char *o;
 842
 843                 result = any >>= o;
 844                   }
 845             else
 846               {
 847                 any <<= i;
 848
 849                 const char *o;
 850
 851                 ACE_hrtime_t start = ACE_OS::gethrtime ();
 852
 853                 result = any >>= o;
 854
 855                 ACE_hrtime_t now = ACE_OS::gethrtime ();
 856                 history.sample (now - start);
 857               }
 858           }
 859
 860         ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 861
 862         if (insertion == 1)
 863           {
 864             ACE_DEBUG ((LM_DEBUG,
 865                         "String insertion test finished\n"));
 866           }
 867         else
 868           {
 869             ACE_DEBUG ((LM_DEBUG,
 870                         "String extraction test finished\n"));
 871           }
 872
 873         ACE_TEST_ASSERT (result);
 874
 875         ACE_DEBUG ((LM_DEBUG,
 876                     "High resolution timer calibration...."));
 877         ACE_High_Res_Timer::global_scale_factor_type gsf =
 878           ACE_High_Res_Timer::global_scale_factor ();
 879         ACE_DEBUG ((LM_DEBUG,
 880                     "done\n"));
 881
 882         ACE_Basic_Stats stats;
 883         history.collect_basic_stats (stats);
 884         stats.dump_results (ACE_TEXT("Total"), gsf);
 885
 886         ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"),
 887                                                gsf,
 888                                                test_end - test_start,
 889                                                stats.samples_count ());
 890       }
 891
 892       ACE_DEBUG ((LM_DEBUG, "\n"));
 893
 894       {
 895         ACE_Sample_History history (n);
 896         ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 897
 898         for (j = 0; j != n; ++j)
 899           {
 900             CORBA::Any any;
 901             const char i[] = "1234567890";
 902             any <<= i;
 903             CORBA::Any copy;
 904
 905             ACE_hrtime_t start = ACE_OS::gethrtime ();
 906
 907             copy = any;
 908
 909             ACE_hrtime_t now = ACE_OS::gethrtime ();
 910             history.sample (now - start);
 911           }
 912
 913         ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 914
 915         ACE_DEBUG ((LM_DEBUG,
 916                     "Copy test finished\n"));
 917         ACE_DEBUG ((LM_DEBUG,
 918                     "High resolution timer calibration...."));
 919         ACE_High_Res_Timer::global_scale_factor_type gsf =
 920           ACE_High_Res_Timer::global_scale_factor ();
 921         ACE_DEBUG ((LM_DEBUG,
 922                     "done\n"));
 923
 924         ACE_Basic_Stats stats;
 925         history.collect_basic_stats (stats);
 926         stats.dump_results (ACE_TEXT("Total"), gsf);
 927
 928         ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"),
 929                                                gsf,
 930                                                test_end - test_start,
 931                                                stats.samples_count ());
 932       }
 933     }
 934   catch (const CORBA::Exception& ex)
 935     {
 936       ex._tao_print_exception ("Any performance test");
 937       return 1;
 938     }
 939
 940   return 0;
 941 }