home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1993 #3 / NN_1993_3.iso / spool / comp / sys / next / programm / 8283 < prev    next >
Encoding:
Text File  |  1993-01-24  |  13.8 KB  |  621 lines
  1. Newsgroups: comp.sys.next.programmer
  2. Path: sparky!uunet!spool.mu.edu!yale.edu!ira.uka.de!uni-heidelberg!vogon!mahilata
  3. From: mahilata@vogon.mathi.uni-heidelberg.de (Earthworm society)
  4. Subject: Request for comment: fake sbrk, dbmalloc on the next
  5. Message-ID: <1993Jan24.102626.18054@sun0.urz.uni-heidelberg.de>
  6. Sender: news@sun0.urz.uni-heidelberg.de (NetNews)
  7. Organization: Matlab, University of Heidelberg
  8. Date: Sun, 24 Jan 93 10:26:26 GMT
  9. Lines: 610
  10.  
  11. This is a request for comment for a fake sbrk as well as for
  12. dbmalloc for the next.
  13.  
  14.  
  15. Fake sbrk RFC
  16.  
  17. Many programs that are around work by sbrk instead of malloc, and
  18. use the property of sbrk to extend the existing memory
  19. such as to keep it a contigous array of whatever.
  20.  
  21. Such as f.ex gap, kant, and (I suspect) Maple.
  22.  
  23. Now the sbrk which next does have (unsupported), indeed obtains exactly 4M,
  24. and after that crashes (and this is exactly the behaviour of maple)
  25.  
  26. So I looked around and found that vm_allocate can be told at which
  27. virtual address to put the new chunk. So, after a bit of experimenting,
  28. I came up with following
  29. =============================== fakesbrk.c ==============================
  30. #ifdef NeXT
  31. #import <mach.h>
  32. #import <stddef.h>
  33. #import <stdlib.h>
  34.  
  35. /*
  36.    NeXT does not have sbrk (or at least they claim so)
  37.    so we use a fake, and use
  38.    vm_allocate.  I still cannot decide if dbmalloc wants
  39.    its working memory contiguous, such as sbrk returns,
  40.    so I depend on vm_allocate to return a virtual chunk
  41.    at a specified address on request.
  42.  
  43.    The env variable MALLOC_ARRAY tells dbmalloc how large one chunk
  44.    got to be. Else it will assume 4M.
  45.  
  46.    This fake sbrk will be used by sbrk_using programs as well,
  47.    via malloc.h
  48. */
  49.  
  50. #define DFLT_ASIZE 4194304
  51. static int fake_array_length;
  52. static int fake_array_chunk;
  53. static char *fake_array;
  54. static char *current_pointer;
  55.  
  56. extern int sprintf(char *s, const char *format, ...);
  57.  
  58. void
  59. init_fake_sbrk()
  60.  
  61.  
  62. {
  63.     kern_return_t rtn;
  64.     char *cptr;
  65.  
  66.     if( (cptr=getenv("MALLOC_ARRAY")) != NULL )
  67.     {
  68.         int xxx=atoi(cptr);
  69.         fake_array_chunk = round_page(xxx);
  70.  
  71.         if( fake_array_chunk < 10000 )
  72.         {
  73.             fake_array_chunk = DFLT_ASIZE;
  74.         }
  75.     }
  76.     else fake_array_chunk = DFLT_ASIZE;
  77.  
  78.     if ((rtn=vm_allocate(task_self(), (vm_address_t *)&fake_array,
  79.         fake_array_chunk, TRUE)) != KERN_SUCCESS)
  80.     {   mach_error("vm_allocate failed", rtn);
  81.         exit(-1);
  82.     }
  83.     current_pointer=fake_array;
  84.     fake_array_length=fake_array_chunk;
  85. /*
  86. {
  87. char aaa[100];
  88. sprintf(aaa,"%d",fake_array_length);
  89. mach_error("YouHoy",0); mach_error(aaa,0);
  90. }
  91. */
  92. }
  93.  
  94. char *
  95. fake_sbrk(int amount)
  96. {
  97.     char * tmp;
  98.     if ((current_pointer+amount)>(fake_array+fake_array_length))
  99.     {    int more, more0;
  100.     char *fake_more=fake_array+fake_array_length;
  101.     char *fmore=fake_more;
  102.         kern_return_t rtn;
  103.  
  104.     more0=(current_pointer+amount)-(fake_array+fake_array_length);
  105.     more=round_page(more0);
  106.     if (more<fake_array_chunk) more=fake_array_chunk;
  107.         if ((rtn=vm_allocate(task_self(), (vm_address_t *)&fake_more,
  108.             more, FALSE)) != KERN_SUCCESS)
  109.         {    mach_error("out of luck",KERN_NO_SPACE);
  110.         exit(-1); /* didn't get any */
  111.         }
  112.     if (fake_more!=fmore)
  113.         {    mach_error("bad luck",KERN_NO_SPACE);
  114.         exit(-1); /* got it wrong */
  115.         }
  116.     fake_array_length+=more;
  117. /*
  118. {
  119. char aaa[100];
  120. sprintf(aaa,"%d",fake_array_length);
  121. mach_error("Yahooo",0); mach_error(aaa,0);
  122. }
  123. */
  124.     }
  125.     tmp=current_pointer;
  126.     current_pointer+=amount;
  127.     return(tmp);
  128. }
  129.  
  130. #endif
  131. ======================================================
  132.  
  133. and a little test program
  134.  
  135. ======================================================
  136. #include <stdio.h>
  137.  
  138. char *fake_sbrk();
  139.  
  140. main()
  141.  
  142. { char *a, *b, *c, *d;
  143.   int x;
  144.   int i=0;
  145.  
  146.   scanf("%d",&x);
  147. init_fake_sbrk();
  148.  
  149.   a=fake_sbrk(0);
  150.   printf("%d\n\n",(int)a);
  151.   scanf("%d",&x);
  152.  
  153.   while (1)
  154.   { i++;
  155.     b=fake_sbrk((int)32768);
  156.     *b='a';
  157.  
  158.     printf("%d: %d \n", i, (int)b-(int)a);
  159.     a=b;
  160.   }
  161. }
  162. ======================================================
  163.  
  164. and lo! this does not crash anymore after 4M.
  165.  
  166. Since this is my first attempt at the innards of next, I would
  167. be really glad over comments about the validity of this.
  168.  
  169. Is this really freely accessible memory?
  170. (I mean the *b='a'; test might not mean really much)
  171.  
  172. and what about the chances for the condition termed
  173. "bad luck" which is memory not contiguous?
  174.  
  175. What about nextstep3? (it *seems* to work)
  176.  
  177. ======================================================
  178. ======================================================
  179.  
  180. The second RFC concerns dbmalloc (earlier mallocdebug),
  181. which was in comp.sources.misc volume 32 (I think) (last year)
  182. and which is tremendously more powerful than MallocDebug
  183. (at least when you cannot use the MallocDebug app since you
  184.  don't debug an app).
  185.  
  186. (In comp.sys.next.programmer there I saw remarks about a great
  187.  many programs handling malloc/free erroneously. I found myself
  188.  quite a few such. dbmalloc on whichever machine is a great tool
  189.  to hunt down things. MallocDebug I found little help)
  190.  
  191. It is for this why I designed the fakesbrk in the first place.
  192.  
  193. But then it turned out that nearly everything of interest
  194. got loaded twice since libsys_s.a is full of crosspointers.
  195. I did not dare to untangle all this, nor to fake it, like
  196. MallocDebug seems to have done. So I dropped all the base
  197. functions malloc, realloc,free (see annexed diff), and
  198. have to trust to the db's malloc.h to switch names.
  199.  
  200. This means that toolbox library
  201. malloc is not caught anymore at ld time. which means that there
  202. are two sets of malloc/free/whatever routines operating
  203. (hopefully) independently of each other. I think this is
  204. a case of what the docs say intermixing of raw vm_allocate
  205. with OS-own malloc, and which has been warned against.
  206.  
  207. On the other hand. I did successfully operate this thing.
  208. In particular on the next I am able to use gdb with this
  209. which I cannot do on a sun nor on an rs6000
  210. (Don't ask me why but it crashes at once)
  211.  
  212.  
  213. Is there any more info out there? Ideas? Suggestions?
  214. Dirty tricks with libsys_s.a? A new pointers.o perhaps?
  215.  
  216. Lastly the diff of dbmalloc. include fakesbrk.c and
  217. insert it in the Makefile.
  218.  
  219.  -mahilata@mathi.uni-heidelberg.de
  220.  
  221. =======================================================
  222. *** gamal/calloc.c    Wed Jan 20 01:06:06 1993
  223. --- ./calloc.c    Sun Jan 24 00:34:10 1993
  224. ***************
  225. *** 32,37 ****
  226. --- 32,38 ----
  227.    *
  228.    * Narrative:    call debug_calloc and return it's return
  229.    */
  230. + #ifndef NeXT
  231.   DATATYPE *
  232.   calloc(nelem,elsize)
  233.       SIZETYPE       nelem;
  234. ***************
  235. *** 39,44 ****
  236. --- 40,46 ----
  237.   {
  238.       return( debug_calloc((char *)NULL,(int)-1,nelem,elsize) );
  239.   }
  240. + #endif
  241.   
  242.   /*
  243.    * Function:    debug_calloc()
  244. *** gamal/dgmalloc.c    Wed Jan 20 01:06:09 1993
  245. --- ./dgmalloc.c    Sun Jan 24 00:58:34 1993
  246. ***************
  247. *** 67,72 ****
  248. --- 67,73 ----
  249.       return( dbmallopt(cmd,&value) );
  250.   }
  251.   
  252. + #ifndef NeXT
  253.   MEMDATA  *
  254.   _bcopy(ptr2, ptr1, len)
  255.       CONST MEMDATA    * ptr2;
  256. ***************
  257. *** 75,81 ****
  258. --- 76,84 ----
  259.   {
  260.       return( DBbcopy((char *)NULL,0,ptr2,ptr1,len) );
  261.   }
  262. + #endif
  263.   
  264. + #ifndef NeXT
  265.   MEMDATA  *
  266.   _bzero(ptr1, len)
  267.       MEMDATA        * ptr1;
  268. ***************
  269. *** 83,88 ****
  270. --- 86,92 ----
  271.   {
  272.       return( DBbzero((char *)NULL,0,ptr1,len) );
  273.   }
  274. + #endif
  275.   
  276.   int
  277.   _bcmp(ptr2, ptr1, len)
  278. *** gamal/free.c    Wed Jan 20 01:06:13 1993
  279. --- ./free.c    Sun Jan 24 00:44:41 1993
  280. ***************
  281. *** 43,48 ****
  282. --- 43,49 ----
  283.   char rcs_hdr[] = "$Id: free.c,v 1.29 1992/08/22 16:27:13 cpcahil Exp $";
  284.   #endif
  285.   
  286. + #ifndef NeXT
  287.   FREETYPE
  288.   free(cptr)
  289.       DATATYPE    * cptr;
  290. ***************
  291. *** 49,54 ****
  292. --- 50,56 ----
  293.   {
  294.       debug_free((char *)NULL, 0, cptr);
  295.   }
  296. + #endif
  297.   
  298.   FREETYPE
  299.   debug_free(file,line,cptr)
  300. *** gamal/m_init.c    Wed Jan 20 01:06:14 1993
  301. --- ./m_init.c    Sat Jan 23 20:48:37 1993
  302. ***************
  303. *** 51,56 ****
  304. --- 51,60 ----
  305.           return;
  306.       }
  307.   
  308. + #ifdef NeXT
  309. +     init_fake_sbrk();
  310. + #endif
  311. + 
  312.   
  313.       malloc_data_start = sbrk(0);
  314.       malloc_data_end = malloc_data_start;
  315. *** gamal/malloc.c    Wed Jan 20 01:06:22 1993
  316. --- ./malloc.c    Sun Jan 24 00:43:33 1993
  317. ***************
  318. *** 89,94 ****
  319. --- 89,95 ----
  320.    * Narrative:
  321.    *
  322.    */
  323. + #ifndef NeXT
  324.   DATATYPE *
  325.   malloc(size)
  326.       SIZETYPE      size;
  327. ***************
  328. *** 95,100 ****
  329. --- 96,102 ----
  330.   {
  331.       return( debug_malloc(NULL,-1,size) );
  332.   }
  333. + #endif
  334.   
  335.   /*
  336.    * Function:    debug_malloc()
  337. *** gamal/malloc.h.org    Wed Jan 20 01:06:16 1993
  338. --- ./malloc.h.org    Sat Jan 23 21:49:35 1993
  339. ***************
  340. *** 15,20 ****
  341. --- 15,24 ----
  342.    * $Id: malloc.h.org,v 1.38 1992/08/22 16:27:13 cpcahil Exp $
  343.    */
  344.   
  345. + #ifdef NeXT
  346. + #define sbrk fake_sbrk
  347. + #endif
  348. + 
  349.   #ifndef _DEBUG_MALLOC_INC
  350.   #define _DEBUG_MALLOC_INC 1
  351.   
  352. *** gamal/memory.c    Wed Jan 20 01:06:30 1993
  353. --- ./memory.c    Sun Jan 24 00:47:35 1993
  354. ***************
  355. *** 128,133 ****
  356. --- 128,134 ----
  357.    * memcpy  - copy one memory area to another
  358.    * memmove - copy one memory area to another
  359.    */
  360. + #ifndef NeXT
  361.   MEMDATA  * 
  362.   memmove(ptr1, ptr2, len)
  363.       MEMDATA         * ptr1;
  364. ***************
  365. *** 136,141 ****
  366. --- 137,143 ----
  367.   {
  368.       return( DBmemmove( (char *) NULL, 0,ptr1, ptr2, len) );
  369.   }
  370. + #endif
  371.   
  372.   MEMDATA  * 
  373.   DBmemmove(file,line,ptr1, ptr2, len)
  374. ***************
  375. *** 250,255 ****
  376. --- 252,258 ----
  377.   /*
  378.    * memset - set all bytes of a memory block to a specified value
  379.    */
  380. + #ifndef NeXT
  381.   MEMDATA  * 
  382.   memset(ptr1, ch, len)
  383.       MEMDATA         * ptr1;
  384. ***************
  385. *** 258,263 ****
  386. --- 261,267 ----
  387.   {
  388.       return( DBmemset((char *)NULL,0,ptr1,ch,len) );
  389.   }
  390. + #endif
  391.   
  392.   MEMDATA  * 
  393.   DBmemset(file,line,ptr1, ch, len)
  394. *** gamal/realloc.c    Sun Jan 24 12:00:01 1993
  395. --- ./realloc.c    Sun Jan 24 00:38:40 1993
  396. ***************
  397. *** 21,26 ****
  398. --- 21,27 ----
  399.   
  400.   #include "mallocin.h"
  401.   
  402. + #ifndef NeXT
  403.   DATATYPE *
  404.   realloc(cptr,size)
  405.       DATATYPE        * cptr;
  406. ***************
  407. *** 28,33 ****
  408. --- 29,35 ----
  409.   {
  410.       return( debug_realloc(NULL,-1,cptr,size) );
  411.   }
  412. + #endif
  413.   
  414.   DATATYPE *
  415.   debug_realloc(file,line,cptr,size)
  416. *** gamal/stack.c    Sun Jan 24 01:34:05 1993
  417. --- ./stack.c    Sun Jan 24 01:47:07 1993
  418. ***************
  419. *** 99,106 ****
  420.        * if there are no entries below this func yet,
  421.        */
  422.       if( this->below == NULL )
  423. !     {
  424. !         this->below = StackNew(func,file,line);
  425.           this->below->above = this;
  426.           current = this->below;
  427.       }
  428. --- 99,107 ----
  429.        * if there are no entries below this func yet,
  430.        */
  431.       if( this->below == NULL )
  432. !     {   struct stack *xxx; xxx=StackNew(func,file,line);
  433. !       /* NeXT cc bug? */
  434. !         this->below = xxx;
  435.           this->below->above = this;
  436.           current = this->below;
  437.       }
  438. ***************
  439. *** 321,329 ****
  440.           /*
  441.            * perform some simple sanity checking on the node pointer
  442.            */
  443. !         if(    (((DATATYPE *)node) < malloc_data_start)
  444.               || (((DATATYPE *)node) > malloc_data_end)
  445. !             || ((((long)node) & 0x1) != 0) )
  446.           {
  447.               WRITEOUT(fd,"INVALID/BROKEN STACK CHAIN!!!\n",30);
  448.               break;
  449. --- 322,334 ----
  450.           /*
  451.            * perform some simple sanity checking on the node pointer
  452.            */
  453. !         if(  
  454. ! #ifndef NeXT
  455. !             (((DATATYPE *)node) < malloc_data_start)
  456.               || (((DATATYPE *)node) > malloc_data_end)
  457. !             ||
  458. ! #endif
  459. !              ((((long)node) & 0x1) != 0) )
  460.           {
  461.               WRITEOUT(fd,"INVALID/BROKEN STACK CHAIN!!!\n",30);
  462.               break;
  463. *** gamal/string.c    Wed Jan 20 01:06:34 1993
  464. --- ./string.c    Sun Jan 24 00:59:21 1993
  465. ***************
  466. *** 451,456 ****
  467. --- 451,457 ----
  468.   /*
  469.    * strcpy - copy a string somewhere else
  470.    */
  471. + #ifndef NeXT
  472.   char *
  473.   strcpy(str1,str2)
  474.       register char        * str1;
  475. ***************
  476. *** 458,463 ****
  477. --- 459,465 ----
  478.   {
  479.       return( DBstrcpy((char *)NULL, 0, str1, str2) );
  480.   }
  481. + #endif
  482.   
  483.   char *
  484.   DBstrcpy(file, line, str1, str2)
  485. ***************
  486. *** 486,491 ****
  487. --- 488,494 ----
  488.   /*
  489.    * strncpy - copy a string upto a specified number of chars somewhere else
  490.    */
  491. + #ifndef NeXT
  492.   char *
  493.   strncpy(str1,str2,len)
  494.       register char        * str1;
  495. ***************
  496. *** 494,499 ****
  497. --- 497,503 ----
  498.   {
  499.       return( DBstrncpy((char *)NULL, 0, str1, str2, len) );
  500.   }
  501. + #endif
  502.   
  503.   char *
  504.   DBstrncpy(file,line,str1,str2,len)
  505. ***************
  506. *** 543,548 ****
  507. --- 547,553 ----
  508.   /*
  509.    * strlen - determine length of a string
  510.    */
  511. + #ifndef NeXT
  512.   STRSIZE 
  513.   strlen(str1)
  514.       CONST char    * str1;
  515. ***************
  516. *** 549,554 ****
  517. --- 554,560 ----
  518.   {
  519.       return( DBstrlen((char *) NULL, 0, str1) );
  520.   }
  521. + #endif
  522.   
  523.   STRSIZE 
  524.   DBstrlen(file, line, str1)
  525. ***************
  526. *** 668,673 ****
  527. --- 674,686 ----
  528.   /*
  529.    * index - find location of character within string
  530.    */
  531. + 
  532. + #ifdef NeXT
  533. + #ifdef index
  534. + #undef index
  535. + #endif
  536. + #endif
  537. + 
  538.   char *
  539.   index(str1,c)
  540.       CONST char        * str1;
  541. ***************
  542. *** 688,693 ****
  543. --- 701,712 ----
  544.   /*
  545.    * rindex - find rightmost location of character within string
  546.    */
  547. + #ifdef NeXT
  548. + #ifdef rindex
  549. + #undef rindex
  550. + #endif
  551. + #endif
  552. + 
  553.   char *
  554.   rindex(str1,c)
  555.       CONST char    * str1;
  556. *** gamal/testmalloc.c    Wed Jan 20 01:06:36 1993
  557. --- ./testmalloc.c    Sun Jan 24 01:05:24 1993
  558. ***************
  559. *** 71,77 ****
  560. --- 71,79 ----
  561.   
  562.       double * dblptr;        /* pointer for doubleword test */
  563.   
  564. + #ifndef NeXT
  565.       extern char end;        /* memory before heap */
  566. + #endif
  567.       char *sbrk();
  568.       long atol();
  569.       union dbmalloptarg m;
  570. ***************
  571. *** 120,128 ****
  572. --- 122,132 ----
  573.       for( i = 0; i < MAXOBJS; i++ )
  574.           objs[ i ] = NULL;
  575.   
  576. + #ifndef NeXT
  577.       startsize = sbrk(0) - &end;
  578.       printf( "Memory use at start: %ld bytes\n", startsize );
  579.       fflush(stdout);
  580. + #endif
  581.   
  582.       printf("Starting the test...\n");
  583.       fflush(stdout);
  584. ***************
  585. *** 223,229 ****
  586. --- 227,235 ----
  587.   
  588.       printf( "Did %ld iterations, %d objects, %d mallocs, %d reallocs\n",
  589.           n, cnt, nm, nre );
  590. + #ifndef NeXT
  591.       printf( "Memory use at end: %ld bytes\n", sbrk(0) - &end );
  592. + #endif
  593.       fflush( stdout );
  594.   
  595.       /* free all the objects */
  596. ***************
  597. *** 242,247 ****
  598. --- 248,254 ----
  599.           }
  600.       }
  601.   
  602. + #ifndef NeXT
  603.       endsize = sbrk(0) - &end;
  604.       printf( "Memory use after free: %ld bytes\n", endsize );
  605.       fflush( stdout );
  606. ***************
  607. *** 248,253 ****
  608. --- 255,261 ----
  609.   
  610.       if( startsize != endsize )
  611.           printf("startsize %ld != endsize %d\n", startsize, endsize );
  612. + #endif
  613.   
  614.       free( (DATATYPE *) objs );
  615.       free( (DATATYPE *) sizes );
  616. -- 
  617.  
  618.  
  619.  --mahilata@mathi.uni-heidelberg.de
  620.  
  621.