test/ooplib.c

   1 /*
   2     Copyright © 1995-2002, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6
   7 /* Prevent inclusion of <intuition/classes.h>,
   8  * which is referenced in the amiga inline macros
   9  * imported below by <proto/exec.h>.
  10  */
  11 #define INTUITION_CLASSES_H
  12
  13 #include <proto/oop.h>
  14 #include <proto/exec.h>
  15 #include <exec/libraries.h>
  16 #include <exec/memory.h>
  17 #include <oop/oop.h>
  18 #include <utility/tagitem.h>
  19 #include <oop/server.h>
  20
  21 #include <stdio.h>
  22 #include <sys/time.h>
  23 #include <unistd.h>
  24
  25
  26 #define SDEBUG 0
  27 #define DEBUG 0
  28 #include <aros/debug.h>
  29
  30 #define MYSERVERID "demoserver"
  31 #define MYTIMERID "timer"
  32
  33 #define SERVERTASK_STACKSIZE 20000
  34
  35 struct ServerParam
  36 {
  37     struct Task *Caller;
  38     ULONG SigBit;
  39 };
  40 struct Task *CreateServerTask(APTR taskparams);
  41
  42
  43 /* --------------------- */
  44 /* Defines below would typically go into the includefile for the class */
  45 #define CLID_Timer "timerclass"
  46
  47 #define IID_Timer "Timer"
  48 #define moTimer_Start   0
  49 #define moTimer_Stop    1
  50 #define moTimer_PrintElapsed 2
  51 #define moTimer_TestMethod      3
  52
  53 #define TimerBase       (__ITimer)
  54 #define M_Timer_Start           (TimerBase + moTimer_Start)
  55 #define M_Timer_Stop            (TimerBase + moTimer_Stop)
  56 #define M_Timer_PrintElapsed    (TimerBase + moTimer_PrintElapsed)
  57 #define M_Timer_TestMethod      (TimerBase + moTimer_TestMethod)
  58
  59
  60 // #define GLOBAL_CLASS
  61
  62 extern ULONG __OOPI_Timer;
  63
  64 /* -------------------------- */
  65
  66 struct Library *OOPBase;
  67
  68 OOP_Class *MakeTimerClass();
  69 VOID FreeTimerClass(OOP_Class *cl);
  70
  71 ULONG __IMeta;
  72 ULONG __ITimer;
  73 ULONG __IMethod;
  74 ULONG __IServer;
  75 ULONG __IInterface;
  76
  77 OOP_Class *timercl;
  78
  79 struct ServerParam sp;
  80
  81 #define NUM_INVOCATIONS 10000L
  82 #define NUM_IF_INVOCATIONS 10000000L
  83
  84 int main (int argc, char **argv)
  85 {
  86     SDInit();
  87
  88
  89
  90     OOPBase = OpenLibrary(AROSOOP_NAME, 0);
  91     if (OOPBase)
  92     {
  93         D(bug("Got OOPBase\n"));
  94         if (
  95                ( __IMeta          = OOP_GetAttrBase( IID_Meta   ))
  96             && ( __ITimer         = OOP_GetAttrBase( IID_Timer  ))
  97             && ( __IMethod        = OOP_GetAttrBase( IID_Method ))
  98             && ( __IServer        = OOP_GetAttrBase( IID_Server ))
  99             && ( __IInterface     = OOP_GetAttrBase( IID_Interface      ))
 100
 101             )
 102         {
 103
 104             D(bug("Got IDs\n"));
 105
 106             timercl = MakeTimerClass();
 107             printf("Timercl: %p\n", timercl);
 108             if (timercl)
 109             {
 110                 /* Create the server task */
 111                 struct Task *servertask;
 112                 OOP_Object *timer;
 113                 struct TagItem tags[] = {{TAG_DONE, 0UL}};
 114
 115                 D(bug("Creating new timer object\n"));
 116
 117                 timer = OOP_NewObject(timercl, NULL, tags);
 118                 D(bug("timer object created\n"));
 119
 120                 if (timer)
 121                 {
 122                     OOP_Method *m;
 123                     ULONG test_mid = OOP_GetMethodID(IID_Timer, moTimer_TestMethod);
 124                     struct TagItem iftags[] =
 125                     {
 126                         { aInterface_TargetObject,      (IPTR)timer},
 127                         { aInterface_InterfaceID,       (IPTR)IID_Timer},
 128                         { TAG_DONE, 0UL }
 129                     };
 130                     struct TagItem mtags[] =
 131                     {
 132                         {aMethod_TargetObject, (IPTR)timer              },
 133                         {aMethod_Message,       (IPTR)&test_mid },
 134                         {aMethod_MethodID,      test_mid        },
 135                         {TAG_DONE,}
 136                     };
 137
 138                     register OOP_Interface *iftimer;
 139                     m = (OOP_Method *)OOP_NewObject(NULL, CLID_Method, mtags);
 140                     if (m)
 141                     {
 142                         printf("Method object created, output: %ld\n",
 143                                 OOP_CallMethod(m));
 144
 145                         OOP_DisposeObject((OOP_Object *)m);
 146                     }
 147
 148
 149
 150                     D(bug("Local timer obj created\n"));
 151
 152                     iftimer = (OOP_Interface *)OOP_NewObject(NULL, CLID_Interface, iftags);
 153                     if (iftimer)
 154                     {
 155                         ULONG test_mid;
 156
 157                         register OOP_Msg msg = (OOP_Msg)&test_mid;
 158
 159                         ULONG i;
 160
 161                         D(bug("iftimer object created\n"));
 162
 163                         printf("Doing %ld invocations using interface objects\n",
 164                                         NUM_IF_INVOCATIONS);
 165
 166                         test_mid = M_Timer_Start;
 167                         iftimer->callMethod(iftimer, (OOP_Msg)&test_mid);
 168
 169                         test_mid = M_Timer_TestMethod;
 170
 171                         for (i = 0; i < NUM_IF_INVOCATIONS; i ++)
 172                         {
 173                             iftimer->callMethod(iftimer, msg);
 174                         }
 175
 176                         test_mid = M_Timer_Stop;
 177                         iftimer->callMethod(iftimer, (OOP_Msg)&test_mid);
 178
 179                         printf("Time elapsed: ");
 180
 181                         test_mid = M_Timer_PrintElapsed;
 182                         iftimer->callMethod(iftimer, (OOP_Msg)&test_mid);
 183
 184                         test_mid = M_Timer_TestMethod;
 185                         printf ("Result of testmethod: %ld\n", iftimer->callMethod(iftimer, (OOP_Msg)&test_mid));
 186
 187
 188                         OOP_DisposeObject((OOP_Object *)iftimer);
 189                     }
 190
 191                     OOP_DisposeObject(timer);
 192                 }
 193
 194
 195                 sp.Caller = FindTask(NULL);
 196
 197                 sp.SigBit = AllocSignal(-1L);
 198
 199
 200
 201                 D(bug("Creating server task\n"));
 202
 203
 204                 servertask = CreateServerTask(&sp);
 205                 if (servertask)
 206                 {
 207
 208                     OOP_Object *server;
 209
 210                     D(bug("server task created: %p\n", servertask));
 211
 212                     Wait(1L << sp.SigBit);
 213                     D(bug("server task has initialized itself: %p\n", servertask));
 214
 215
 216                     if ( (server = OOP_FindServer(MYSERVERID)) )
 217                     {
 218                         OOP_Object *timer;
 219
 220                         D(bug("Server found: %p\n", server));
 221
 222                         if ( (timer = Server_FindObject(server, MYTIMERID)) )
 223                         {
 224                             ULONG test_mid;
 225
 226                             ULONG i;
 227
 228                             printf("Doing %ld invocations using IPC\n",
 229                                         NUM_INVOCATIONS);
 230
 231                             test_mid = OOP_GetMethodID(IID_Timer, moTimer_Start);
 232                             OOP_DoMethod(timer, (OOP_Msg)&test_mid);
 233
 234                             test_mid = OOP_GetMethodID(IID_Timer, moTimer_TestMethod);
 235                             for (i = 0; i < NUM_INVOCATIONS; i ++)
 236                             {
 237                                 OOP_DoMethod(timer, (OOP_Msg)&test_mid);
 238                             }
 239
 240                             test_mid = OOP_GetMethodID(IID_Timer, moTimer_Stop);
 241                             OOP_DoMethod(timer, (OOP_Msg)&test_mid);
 242
 243                             printf("Time elapsed: ");
 244
 245                             test_mid = OOP_GetMethodID(IID_Timer, moTimer_PrintElapsed);
 246                             OOP_DoMethod(timer, (OOP_Msg)&test_mid);
 247
 248                             test_mid = OOP_GetMethodID(IID_Timer, moTimer_TestMethod);
 249                             printf ("Result of testmethod: %ld\n", OOP_DoMethod(timer, (OOP_Msg)&test_mid));
 250
 251
 252                         }
 253
 254                     }
 255
 256                 }
 257
 258                 FreeTimerClass(timercl);
 259             }
 260
 261         }
 262         CloseLibrary(OOPBase);
 263
 264     }
 265     return (0);
 266 }
 267
 268
 269
 270 struct TimerData
 271 {
 272     struct timeval start_time;
 273     struct timeval elapsed_time;
 274 };
 275
 276 VOID SubTime(struct timeval *dest, struct timeval *src)
 277 {
 278     while(src->tv_usec > 999999)
 279     {
 280         src->tv_sec++;
 281         src->tv_usec -= 1000000;
 282     }
 283     while(dest->tv_usec > 999999)
 284     {
 285         dest->tv_sec++;
 286         dest->tv_usec -= 1000000;
 287     }
 288
 289     dest->tv_usec -= src->tv_usec;
 290     dest->tv_sec -= src->tv_sec;
 291
 292     if(dest->tv_usec < 0)
 293     {
 294         dest->tv_usec += 1000000;
 295         dest->tv_sec--;
 296     }
 297
 298     return;
 299 }
 300
 301 #ifdef GLOBAL_CLASS
 302 Class *tcl;
 303 #endif
 304
 305 VOID _Timer_Start(
 306 #ifndef GLOBAL_CLASS
 307 OOP_Class *tcl,
 308 #endif
 309 OOP_Object *o, OOP_Msg msg)
 310 {
 311     struct TimerData *data;
 312     EnterFunc(bug("Timer::Start(o=%p)\n", o));
 313
 314     data = OOP_INST_DATA(tcl, o);
 315     D(bug("data=%p\n", data));
 316
 317     gettimeofday(&(data->start_time), NULL);
 318
 319     ReturnVoid("Timer::Start");
 320 }
 321
 322 VOID _Timer_Stop(
 323 #ifndef GLOBAL_CLASS
 324 OOP_Class *tcl,
 325 #endif
 326 OOP_Object *o, OOP_Msg msg)
 327 {
 328     struct TimerData *data = OOP_INST_DATA(tcl, o);
 329     gettimeofday(&(data->elapsed_time), NULL);
 330
 331     SubTime(&(data->elapsed_time), &(data->start_time));
 332
 333     return;
 334 }
 335
 336 VOID _Timer_PrintElapsed(
 337 #ifndef GLOBAL_CLASS
 338 OOP_Class *tcl,
 339 #endif
 340 OOP_Object *o, OOP_Msg msg)
 341 {
 342     struct TimerData *data = OOP_INST_DATA(tcl, o);
 343
 344     kprintf("%ld secs and %ld micros\n"
 345         ,data->elapsed_time.tv_sec
 346         ,data->elapsed_time.tv_usec);
 347
 348 }
 349
 350 IPTR _Timer_TestMethod(
 351 #ifndef GLOBAL_CLASS
 352 OOP_Class *tcl,
 353 #endif
 354 OOP_Object *o, OOP_Msg msg)
 355 {
 356     return (12345678);
 357 }
 358
 359
 360 OOP_Class *MakeTimerClass()
 361 {
 362
 363     struct OOP_MethodDescr methods[] =
 364     {
 365         {(IPTR (*)())_Timer_Start,              moTimer_Start},
 366         {(IPTR (*)())_Timer_Stop,               moTimer_Stop},
 367         {(IPTR (*)())_Timer_PrintElapsed,       moTimer_PrintElapsed},
 368         {(IPTR (*)())_Timer_TestMethod,         moTimer_TestMethod},
 369         {NULL, 0UL}
 370
 371     };
 372
 373     struct OOP_InterfaceDescr ifdescr[] =
 374     {
 375         { methods, "Timer", 4},
 376         { NULL, 0UL, 0UL}
 377     };
 378
 379     struct TagItem tags[] =
 380     {
 381         {aMeta_SuperID,         (IPTR)CLID_Root},
 382         {aMeta_InterfaceDescr,          (IPTR)ifdescr},
 383         {aMeta_ID,                      (IPTR)CLID_Timer},
 384         {aMeta_InstSize,                (IPTR)sizeof (struct TimerData)},
 385         {TAG_DONE, 0UL}
 386     };
 387 #ifndef GLOBAL_CLASS
 388 OOP_Class *tcl;
 389 #endif
 390
 391
 392     tcl = (OOP_Class *)OOP_NewObject(NULL, CLID_MIMeta, tags);
 393
 394
 395     if (tcl)
 396     {
 397 //      OOP_AddClass(tcl);
 398     }
 399
 400     return (tcl);
 401 }
 402
 403 VOID FreeTimerClass(OOP_Class *cl)
 404 {
 405     OOP_DisposeObject((OOP_Object *)cl);
 406
 407     return;
 408
 409 }
 410
 411 VOID TaskEntryPoint(struct ServerParam *p)
 412 {
 413     OOP_Object *server;
 414
 415     BOOL success = FALSE;
 416
 417
 418     struct TagItem server_tags[] =
 419     {
 420         { TAG_DONE, 0UL}
 421     };
 422
 423
 424     D(bug("Entering servertask...\n"));
 425
 426     server = OOP_NewObject(NULL, CLID_Server, server_tags);
 427     if (server)
 428     {
 429         D(bug("st: server created\n"));
 430         if (OOP_AddServer(server, MYSERVERID))
 431         {
 432
 433             OOP_Object *timer;
 434
 435             struct TagItem timer_tags[] =
 436             {
 437                 { TAG_DONE, 0UL}
 438             };
 439             D(bug("st: server added\n"));
 440
 441             timer = OOP_NewObject(timercl, NULL, timer_tags);
 442             if (timer)
 443             {
 444                 D(bug("st: timer created\n"));
 445                 if (Server_AddObject(server, timer, MYTIMERID))
 446                 {
 447                      D(bug("st: timer added to server\n"));
 448
 449                      Signal(p->Caller, 1L << p->SigBit);
 450
 451                      Server_Run(server);
 452
 453                      Server_RemoveObject(server, MYTIMERID);
 454                      success = TRUE;
 455
 456                 }
 457                 OOP_DisposeObject(timer);
 458
 459             }
 460             OOP_RemoveServer(MYSERVERID);
 461         }
 462         OOP_DisposeObject(server);
 463
 464
 465     }
 466
 467
 468     /* Just in case */
 469     if (!success)
 470     {
 471         D(bug("st: No success\n"));
 472         Signal(p->Caller, 1L << p->SigBit);
 473     }
 474     return;
 475
 476 }
 477
 478 struct Task *CreateServerTask(APTR taskparams)
 479 {
 480     struct Task *task;
 481     APTR stack;
 482
 483     task = AllocMem(sizeof (struct Task), MEMF_PUBLIC|MEMF_CLEAR);
 484     if (task)
 485     {
 486         NEWLIST(&task->tc_MemEntry);
 487         task->tc_Node.ln_Type=NT_TASK;
 488         task->tc_Node.ln_Name="demoserver";
 489         task->tc_Node.ln_Pri = 0;
 490
 491         stack=AllocMem(SERVERTASK_STACKSIZE, MEMF_PUBLIC);
 492         if(stack != NULL)
 493         {
 494             task->tc_SPLower=stack;
 495             task->tc_SPUpper=(BYTE *)stack + SERVERTASK_STACKSIZE;
 496
 497 #if AROS_STACK_GROWS_DOWNWARDS
 498             task->tc_SPReg = (BYTE *)task->tc_SPUpper-SP_OFFSET - sizeof(APTR);
 499             ((APTR *)task->tc_SPUpper)[-1] = taskparams;
 500 #else
 501             task->tc_SPReg=(BYTE *)task->tc_SPLower-SP_OFFSET + sizeof(APTR);
 502             *(APTR *)task->tc_SPLower = taskparams;
 503 #endif
 504
 505             if(AddTask(task, TaskEntryPoint, NULL) != NULL)
 506             {
 507                 /* Everything went OK */
 508                 return (task);
 509             }
 510             FreeMem(stack, SERVERTASK_STACKSIZE);
 511         }
 512         FreeMem(task,sizeof(struct Task));
 513     }
 514     return (NULL);
 515
 516 }
 517