boehm-gc/AmigaOS.c

   1
   2
   3 /******************************************************************
   4
   5   AmigaOS-spesific routines for GC.
   6   This file is normally included from os_dep.c
   7
   8 ******************************************************************/
   9
  10
  11 #if !defined(GC_AMIGA_DEF) && !defined(GC_AMIGA_SB) && !defined(GC_AMIGA_DS) && !defined(GC_AMIGA_AM)
  12 # include "gc_priv.h"
  13 # include <stdio.h>
  14 # include <signal.h>
  15 # define GC_AMIGA_DEF
  16 # define GC_AMIGA_SB
  17 # define GC_AMIGA_DS
  18 # define GC_AMIGA_AM
  19 #endif
  20
  21
  22 #ifdef GC_AMIGA_DEF
  23
  24 # ifndef __GNUC__
  25 #   include <exec/exec.h>
  26 # endif
  27 # include <proto/exec.h>
  28 # include <proto/dos.h>
  29 # include <dos/dosextens.h>
  30 # include <workbench/startup.h>
  31
  32 #endif
  33
  34
  35
  36
  37 #ifdef GC_AMIGA_SB
  38
  39 /******************************************************************
  40    Find the base of the stack.
  41 ******************************************************************/
  42
  43 ptr_t GC_get_stack_base()
  44 {
  45     struct Process *proc = (struct Process*)SysBase->ThisTask;
  46
  47     /* Reference: Amiga Guru Book Pages: 42,567,574 */
  48     if (proc->pr_Task.tc_Node.ln_Type==NT_PROCESS
  49         && proc->pr_CLI != NULL) {
  50         /* first ULONG is StackSize */
  51         /*longPtr = proc->pr_ReturnAddr;
  52         size = longPtr[0];*/
  53
  54         return (char *)proc->pr_ReturnAddr + sizeof(ULONG);
  55     } else {
  56         return (char *)proc->pr_Task.tc_SPUpper;
  57     }
  58 }
  59
  60 #if 0 /* old version */
  61 ptr_t GC_get_stack_base()
  62 {
  63     extern struct WBStartup *_WBenchMsg;
  64     extern long __base;
  65     extern long __stack;
  66     struct Task *task;
  67     struct Process *proc;
  68     struct CommandLineInterface *cli;
  69     long size;
  70
  71     if ((task = FindTask(0)) == 0) {
  72         GC_err_puts("Cannot find own task structure\n");
  73         ABORT("task missing");
  74     }
  75     proc = (struct Process *)task;
  76     cli = BADDR(proc->pr_CLI);
  77
  78     if (_WBenchMsg != 0 || cli == 0) {
  79         size = (char *)task->tc_SPUpper - (char *)task->tc_SPLower;
  80     } else {
  81         size = cli->cli_DefaultStack * 4;
  82     }
  83     return (ptr_t)(__base + GC_max(size, __stack));
  84 }
  85 #endif
  86
  87
  88 #endif
  89
  90
  91 #ifdef GC_AMIGA_DS
  92 /******************************************************************
  93    Register data segments.
  94 ******************************************************************/
  95
  96    void GC_register_data_segments()
  97    {
  98      struct Process     *proc;
  99      struct CommandLineInterface *cli;
 100      BPTR myseglist;
 101      ULONG *data;
 102
 103      int        num;
 104
 105
 106 #    ifdef __GNUC__
 107         ULONG dataSegSize;
 108         GC_bool found_segment = FALSE;
 109         extern char __data_size[];
 110
 111         dataSegSize=__data_size+8;
 112         /* Can`t find the Location of __data_size, because
 113            it`s possible that is it, inside the segment. */
 114
 115 #     endif
 116
 117         proc= (struct Process*)SysBase->ThisTask;
 118
 119         /* Reference: Amiga Guru Book Pages: 538ff,565,573
 120                      and XOper.asm */
 121         if (proc->pr_Task.tc_Node.ln_Type==NT_PROCESS) {
 122           if (proc->pr_CLI == NULL) {
 123             myseglist = proc->pr_SegList;
 124           } else {
 125             /* ProcLoaded       'Loaded as a command: '*/
 126             cli = BADDR(proc->pr_CLI);
 127             myseglist = cli->cli_Module;
 128           }
 129         } else {
 130           ABORT("Not a Process.");
 131         }
 132
 133         if (myseglist == NULL) {
 134             ABORT("Arrrgh.. can't find segments, aborting");
 135         }
 136
 137         /* xoper hunks Shell Process */
 138
 139         num=0;
 140         for (data = (ULONG *)BADDR(myseglist); data != NULL;
 141              data = (ULONG *)BADDR(data[0])) {
 142           if (((ULONG) GC_register_data_segments < (ULONG) &data[1]) ||
 143               ((ULONG) GC_register_data_segments > (ULONG) &data[1] + data[-1])) {
 144 #             ifdef __GNUC__
 145                 if (dataSegSize == data[-1]) {
 146                   found_segment = TRUE;
 147                 }
 148 #             endif
 149               GC_add_roots_inner((char *)&data[1],
 150                                  ((char *)&data[1]) + data[-1], FALSE);
 151           }
 152           ++num;
 153         } /* for */
 154 #       ifdef __GNUC__
 155            if (!found_segment) {
 156              ABORT("Can`t find correct Segments.\nSolution: Use an newer version of ixemul.library");
 157            }
 158 #       endif
 159   }
 160
 161 #if 0 /* old version */
 162   void GC_register_data_segments()
 163   {
 164     extern struct WBStartup *_WBenchMsg;
 165     struct Process      *proc;
 166     struct CommandLineInterface *cli;
 167     BPTR myseglist;
 168     ULONG *data;
 169
 170     if ( _WBenchMsg != 0 ) {
 171         if ((myseglist = _WBenchMsg->sm_Segment) == 0) {
 172             GC_err_puts("No seglist from workbench\n");
 173             return;
 174         }
 175     } else {
 176         if ((proc = (struct Process *)FindTask(0)) == 0) {
 177             GC_err_puts("Cannot find process structure\n");
 178             return;
 179         }
 180         if ((cli = BADDR(proc->pr_CLI)) == 0) {
 181             GC_err_puts("No CLI\n");
 182             return;
 183         }
 184         if ((myseglist = cli->cli_Module) == 0) {
 185             GC_err_puts("No seglist from CLI\n");
 186             return;
 187         }
 188     }
 189
 190     for (data = (ULONG *)BADDR(myseglist); data != 0;
 191          data = (ULONG *)BADDR(data[0])) {
 192 #        ifdef AMIGA_SKIP_SEG
 193            if (((ULONG) GC_register_data_segments < (ULONG) &data[1]) ||
 194            ((ULONG) GC_register_data_segments > (ULONG) &data[1] + data[-1])) {
 195 #        else
 196            {
 197 #        endif /* AMIGA_SKIP_SEG */
 198           GC_add_roots_inner((char *)&data[1],
 199                              ((char *)&data[1]) + data[-1], FALSE);
 200          }
 201     }
 202   }
 203 #endif /* old version */
 204
 205
 206 #endif
 207
 208
 209
 210 #ifdef GC_AMIGA_AM
 211
 212 #ifndef GC_AMIGA_FASTALLOC
 213
 214 void *GC_amiga_allocwrapper(size_t size,void *(*AllocFunction)(size_t size2)){
 215         return (*AllocFunction)(size);
 216 }
 217
 218 void *(*GC_amiga_allocwrapper_do)(size_t size,void *(*AllocFunction)(size_t size2))
 219         =GC_amiga_allocwrapper;
 220
 221 #else
 222
 223
 224
 225
 226 void *GC_amiga_allocwrapper_firsttime(size_t size,void *(*AllocFunction)(size_t size2));
 227
 228 void *(*GC_amiga_allocwrapper_do)(size_t size,void *(*AllocFunction)(size_t size2))
 229         =GC_amiga_allocwrapper_firsttime;
 230
 231
 232 /******************************************************************
 233    Amiga-spesific routines to obtain memory, and force GC to give
 234    back fast-mem whenever possible.
 235         These hacks makes gc-programs go many times faster when
 236    the amiga is low on memory, and are therefore strictly necesarry.
 237
 238    -Kjetil S. Matheussen, 2000.
 239 ******************************************************************/
 240
 241
 242
 243 /* List-header for all allocated memory. */
 244
 245 struct GC_Amiga_AllocedMemoryHeader{
 246         ULONG size;
 247         struct GC_Amiga_AllocedMemoryHeader *next;
 248 };
 249 struct GC_Amiga_AllocedMemoryHeader *GC_AMIGAMEM=(struct GC_Amiga_AllocedMemoryHeader *)(int)~(NULL);
 250
 251
 252
 253 /* Type of memory. Once in the execution of a program, this might change to MEMF_ANY|MEMF_CLEAR */
 254
 255 ULONG GC_AMIGA_MEMF = MEMF_FAST | MEMF_CLEAR;
 256
 257
 258 /* Prevents GC_amiga_get_mem from allocating memory if this one is TRUE. */
 259 #ifndef GC_AMIGA_ONLYFAST
 260 BOOL GC_amiga_dontalloc=FALSE;
 261 #endif
 262
 263 #ifdef GC_AMIGA_PRINTSTATS
 264 int succ=0,succ2=0;
 265 int nsucc=0,nsucc2=0;
 266 int nullretries=0;
 267 int numcollects=0;
 268 int chipa=0;
 269 int allochip=0;
 270 int allocfast=0;
 271 int cur0=0;
 272 int cur1=0;
 273 int cur10=0;
 274 int cur50=0;
 275 int cur150=0;
 276 int cur151=0;
 277 int ncur0=0;
 278 int ncur1=0;
 279 int ncur10=0;
 280 int ncur50=0;
 281 int ncur150=0;
 282 int ncur151=0;
 283 #endif
 284
 285 /* Free everything at program-end. */
 286
 287 void GC_amiga_free_all_mem(void){
 288         struct GC_Amiga_AllocedMemoryHeader *gc_am=(struct GC_Amiga_AllocedMemoryHeader *)(~(int)(GC_AMIGAMEM));
 289         struct GC_Amiga_AllocedMemoryHeader *temp;
 290
 291 #ifdef GC_AMIGA_PRINTSTATS
 292         printf("\n\n"
 293                 "%d bytes of chip-mem, and %d bytes of fast-mem where allocated from the OS.\n",
 294                 allochip,allocfast
 295         );
 296         printf(
 297                 "%d bytes of chip-mem were returned from the GC_AMIGA_FASTALLOC supported allocating functions.\n",
 298                 chipa
 299         );
 300         printf("\n");
 301         printf("GC_gcollect was called %d times to avoid returning NULL or start allocating with the MEMF_ANY flag.\n",numcollects);
 302         printf("%d of them was a success. (the others had to use allocation from the OS.)\n",nullretries);
 303         printf("\n");
 304         printf("Succeded forcing %d gc-allocations (%d bytes) of chip-mem to be fast-mem.\n",succ,succ2);
 305         printf("Failed forcing %d gc-allocations (%d bytes) of chip-mem to be fast-mem.\n",nsucc,nsucc2);
 306         printf("\n");
 307         printf(
 308                 "Number of retries before succeding a chip->fast force:\n"
 309                 "0: %d, 1: %d, 2-9: %d, 10-49: %d, 50-149: %d, >150: %d\n",
 310                 cur0,cur1,cur10,cur50,cur150,cur151
 311         );
 312         printf(
 313                 "Number of retries before giving up a chip->fast force:\n"
 314                 "0: %d, 1: %d, 2-9: %d, 10-49: %d, 50-149: %d, >150: %d\n",
 315                 ncur0,ncur1,ncur10,ncur50,ncur150,ncur151
 316         );
 317 #endif
 318
 319         while(gc_am!=NULL){
 320                 temp=gc_am->next;
 321                 FreeMem(gc_am,gc_am->size);
 322                 gc_am=(struct GC_Amiga_AllocedMemoryHeader *)(~(int)(temp));
 323         }
 324 }
 325
 326 #ifndef GC_AMIGA_ONLYFAST
 327
 328 /* All memory with address lower than this one is chip-mem. */
 329
 330 char *chipmax;
 331
 332
 333 /*
 334  * Allways set to the last size of memory tried to be allocated.
 335  * Needed to ensure allocation when the size is bigger than 100000.
 336  *
 337  */
 338 size_t latestsize;
 339
 340 #endif
 341
 342
 343 /*
 344  * The actual function that is called with the GET_MEM macro.
 345  *
 346  */
 347
 348 void *GC_amiga_get_mem(size_t size){
 349         struct GC_Amiga_AllocedMemoryHeader *gc_am;
 350
 351 #ifndef GC_AMIGA_ONLYFAST
 352         if(GC_amiga_dontalloc==TRUE){
 353 //              printf("rejected, size: %d, latestsize: %d\n",size,latestsize);
 354                 return NULL;
 355         }
 356
 357         // We really don't want to use chip-mem, but if we must, then as little as possible.
 358         if(GC_AMIGA_MEMF==(MEMF_ANY|MEMF_CLEAR) && size>100000 && latestsize<50000) return NULL;
 359 #endif
 360
 361         gc_am=AllocMem((ULONG)(size + sizeof(struct GC_Amiga_AllocedMemoryHeader)),GC_AMIGA_MEMF);
 362         if(gc_am==NULL) return NULL;
 363
 364         gc_am->next=GC_AMIGAMEM;
 365         gc_am->size=size + sizeof(struct GC_Amiga_AllocedMemoryHeader);
 366         GC_AMIGAMEM=(struct GC_Amiga_AllocedMemoryHeader *)(~(int)(gc_am));
 367
 368 //      printf("Allocated %d (%d) bytes at address: %x. Latest: %d\n",size,tot,gc_am,latestsize);
 369
 370 #ifdef GC_AMIGA_PRINTSTATS
 371         if((char *)gc_am<chipmax){
 372                 allochip+=size;
 373         }else{
 374                 allocfast+=size;
 375         }
 376 #endif
 377
 378         return gc_am+1;
 379
 380 }
 381
 382
 383
 384
 385 #ifndef GC_AMIGA_ONLYFAST
 386
 387 /* Tries very hard to force GC to find fast-mem to return. Done recursively
 388  * to hold the rejected memory-pointers reachable from the collector in an
 389  * easy way.
 390  *
 391  */
 392 #ifdef GC_AMIGA_RETRY
 393 void *GC_amiga_rec_alloc(size_t size,void *(*AllocFunction)(size_t size2),const int rec){
 394         void *ret;
 395
 396         ret=(*AllocFunction)(size);
 397
 398 #ifdef GC_AMIGA_PRINTSTATS
 399         if((char *)ret>chipmax || ret==NULL){
 400                 if(ret==NULL){
 401                         nsucc++;
 402                         nsucc2+=size;
 403                         if(rec==0) ncur0++;
 404                         if(rec==1) ncur1++;
 405                         if(rec>1 && rec<10) ncur10++;
 406                         if(rec>=10 && rec<50) ncur50++;
 407                         if(rec>=50 && rec<150) ncur150++;
 408                         if(rec>=150) ncur151++;
 409                 }else{
 410                         succ++;
 411                         succ2+=size;
 412                         if(rec==0) cur0++;
 413                         if(rec==1) cur1++;
 414                         if(rec>1 && rec<10) cur10++;
 415                         if(rec>=10 && rec<50) cur50++;
 416                         if(rec>=50 && rec<150) cur150++;
 417                         if(rec>=150) cur151++;
 418                 }
 419         }
 420 #endif
 421
 422         if (((char *)ret)<=chipmax && ret!=NULL && (rec<(size>500000?9:size/5000))){
 423                 ret=GC_amiga_rec_alloc(size,AllocFunction,rec+1);
 424 //              GC_free(ret2);
 425         }
 426
 427         return ret;
 428 }
 429 #endif
 430
 431
 432 /* The allocating-functions defined inside the amiga-blocks in gc.h is called
 433  * via these functions.
 434  */
 435
 436
 437 void *GC_amiga_allocwrapper_any(size_t size,void *(*AllocFunction)(size_t size2)){
 438         void *ret,*ret2;
 439
 440         GC_amiga_dontalloc=TRUE;        // Pretty tough thing to do, but its indeed necesarry.
 441         latestsize=size;
 442
 443         ret=(*AllocFunction)(size);
 444
 445         if(((char *)ret) <= chipmax){
 446                 if(ret==NULL){
 447                         //Give GC access to allocate memory.
 448 #ifdef GC_AMIGA_GC
 449                         if(!GC_dont_gc){
 450                                 GC_gcollect();
 451 #ifdef GC_AMIGA_PRINTSTATS
 452                                 numcollects++;
 453 #endif
 454                                 ret=(*AllocFunction)(size);
 455                         }
 456 #endif
 457                         if(ret==NULL){
 458                                 GC_amiga_dontalloc=FALSE;
 459                                 ret=(*AllocFunction)(size);
 460                                 if(ret==NULL){
 461                                         WARN("Out of Memory!  Returning NIL!\n", 0);
 462                                 }
 463                         }
 464 #ifdef GC_AMIGA_PRINTSTATS
 465                         else{
 466                                 nullretries++;
 467                         }
 468                         if(ret!=NULL && (char *)ret<=chipmax) chipa+=size;
 469 #endif
 470                 }
 471 #ifdef GC_AMIGA_RETRY
 472                 else{
 473                         /* We got chip-mem. Better try again and again and again etc., we might get fast-mem sooner or later... */
 474                         /* Using gctest to check the effectiviness of doing this, does seldom give a very good result. */
 475                         /* However, real programs doesn't normally rapidly allocate and deallocate. */
 476 //                      printf("trying to force... %d bytes... ",size);
 477                         if(
 478                                 AllocFunction!=GC_malloc_uncollectable
 479 #ifdef ATOMIC_UNCOLLECTABLE
 480                                 && AllocFunction!=GC_malloc_atomic_uncollectable
 481 #endif
 482                         ){
 483                                 ret2=GC_amiga_rec_alloc(size,AllocFunction,0);
 484                         }else{
 485                                 ret2=(*AllocFunction)(size);
 486 #ifdef GC_AMIGA_PRINTSTATS
 487                                 if((char *)ret2<chipmax || ret2==NULL){
 488                                         nsucc++;
 489                                         nsucc2+=size;
 490                                         ncur0++;
 491                                 }else{
 492                                         succ++;
 493                                         succ2+=size;
 494                                         cur0++;
 495                                 }
 496 #endif
 497                         }
 498                         if(((char *)ret2)>chipmax){
 499 //                              printf("Succeeded.\n");
 500                                 GC_free(ret);
 501                                 ret=ret2;
 502                         }else{
 503                                 GC_free(ret2);
 504 //                              printf("But did not succeed.\n");
 505                         }
 506                 }
 507 #endif
 508         }
 509
 510         GC_amiga_dontalloc=FALSE;
 511
 512         return ret;
 513 }
 514
 515
 516
 517 void (*GC_amiga_toany)(void)=NULL;
 518
 519 void GC_amiga_set_toany(void (*func)(void)){
 520         GC_amiga_toany=func;
 521 }
 522
 523 #endif // !GC_AMIGA_ONLYFAST
 524
 525
 526 void *GC_amiga_allocwrapper_fast(size_t size,void *(*AllocFunction)(size_t size2)){
 527         void *ret;
 528
 529         ret=(*AllocFunction)(size);
 530
 531         if(ret==NULL){
 532                 // Enable chip-mem allocation.
 533 //              printf("ret==NULL\n");
 534 #ifdef GC_AMIGA_GC
 535                 if(!GC_dont_gc){
 536                         GC_gcollect();
 537 #ifdef GC_AMIGA_PRINTSTATS
 538                         numcollects++;
 539 #endif
 540                         ret=(*AllocFunction)(size);
 541                 }
 542 #endif
 543                 if(ret==NULL){
 544 #ifndef GC_AMIGA_ONLYFAST
 545                         GC_AMIGA_MEMF=MEMF_ANY | MEMF_CLEAR;
 546                         if(GC_amiga_toany!=NULL) (*GC_amiga_toany)();
 547                         GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_any;
 548                         return GC_amiga_allocwrapper_any(size,AllocFunction);
 549 #endif
 550                 }
 551 #ifdef GC_AMIGA_PRINTSTATS
 552                 else{
 553                         nullretries++;
 554                 }
 555 #endif
 556         }
 557
 558         return ret;
 559 }
 560
 561 void *GC_amiga_allocwrapper_firsttime(size_t size,void *(*AllocFunction)(size_t size2)){
 562         atexit(&GC_amiga_free_all_mem);
 563         chipmax=(char *)SysBase->MaxLocMem;             // For people still having SysBase in chip-mem, this might speed up a bit.
 564         GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_fast;
 565         return GC_amiga_allocwrapper_fast(size,AllocFunction);
 566 }
 567
 568
 569 #endif //GC_AMIGA_FASTALLOC
 570
 571
 572
 573 /*
 574  * The wrapped realloc function.
 575  *
 576  */
 577 void *GC_amiga_realloc(void *old_object,size_t new_size_in_bytes){
 578 #ifndef GC_AMIGA_FASTALLOC
 579         return GC_realloc(old_object,new_size_in_bytes);
 580 #else
 581         void *ret;
 582         latestsize=new_size_in_bytes;
 583         ret=GC_realloc(old_object,new_size_in_bytes);
 584         if(ret==NULL && GC_AMIGA_MEMF==(MEMF_FAST | MEMF_CLEAR)){
 585                 /* Out of fast-mem. */
 586 #ifdef GC_AMIGA_GC
 587                 if(!GC_dont_gc){
 588                         GC_gcollect();
 589 #ifdef GC_AMIGA_PRINTSTATS
 590                         numcollects++;
 591 #endif
 592                         ret=GC_realloc(old_object,new_size_in_bytes);
 593                 }
 594 #endif
 595                 if(ret==NULL){
 596 #ifndef GC_AMIGA_ONLYFAST
 597                         GC_AMIGA_MEMF=MEMF_ANY | MEMF_CLEAR;
 598                         if(GC_amiga_toany!=NULL) (*GC_amiga_toany)();
 599                         GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_any;
 600                         ret=GC_realloc(old_object,new_size_in_bytes);
 601 #endif
 602                 }
 603 #ifdef GC_AMIGA_PRINTSTATS
 604                 else{
 605                         nullretries++;
 606                 }
 607 #endif
 608         }
 609         if(ret==NULL){
 610                 WARN("Out of Memory!  Returning NIL!\n", 0);
 611         }
 612 #ifdef GC_AMIGA_PRINTSTATS
 613         if(((char *)ret)<chipmax && ret!=NULL){
 614                 chipa+=new_size_in_bytes;
 615         }
 616 #endif
 617         return ret;
 618 #endif
 619 }
 620
 621 #endif //GC_AMIGA_AM
 622
 623