The Fred Fish Collection 1.5/ffcollection-1-5-1992-11.iso/ff_progs/mem_util/memfrag.lzh/MEMFRAG/MEMFRAG.C

C/C++ Source or Header | 1991-08-17 | 5.1 KB | 231 lines

/************************************************************************
*                                                                       *
*                                                                       *
*                      Filename:        MemFrag.c                       *
*                       Version:        0.0                             *
*                       Author :        Gary Duncan                     *
*                                                                       *
*                                frags , heavily modified               *
*-----------------------------------------------------------------------*
*
* Function:
* ~~~~~~~~~
*
* Invocation:
* ~~~~~~~~~~
*
*
* Modification record:
*~~~~~~~~~~~~~~~~~~~~
*
* Date         By whom             Change
* ----         -------             ------
*
* 17 Jan 89    GMD          Original ; frags.c heavily modified
*                                            ( from FF69)
*
* 01 Jul 89    "          Date added
*
* Contents:    Function    Description
* ~~~~~~~~     ~~~~~~~~    ~~~~~~~~~~~
*+
*+  _main
*+  print_count
*+  ascify
*+  MemCleanup
*+
*
*
*******************************************************************************/


#include "gd_functions.h"


#include <exec/types.h>
#include <exec/exec.h>
#include <exec/execbase.h>


extern char *MakeDate[] ;

#if 0
char redpen[]  =  "\033[33m";      /* red pen     */
char witepen[] =  "\033[0m";      /* white  pen  */
#endif

char ghdr[] = "\n\033[33m\
                   Chip:Fast \n\
                   ~~~~ ~~~~\033[0m\n" ;

char buffer[100] = "12345678 : 123     123 :123         \n"  ;

struct gazza { int   kk ;
                BYTE chip ;
                BYTE fast ; }  Chunk_Count[25] ;



_main()
{

long aggrF = 0 ;        /* GMD    */
long aggrC = 0 ;        /* GMD    */
char flag ;
struct MemHeader *hdr ;
struct MemChunk *chunk ;
long    size ;
extern struct ExecBase *SysBase ;
short j ;

    {
     char vvv[100] ;
     sprintf ( vvv, "\nMemFrag: (%s) \n",
                MakeDate[0] ) ;
     Write(Output(), vvv, (long)strlen(vvv) ) ;    /* GMD */
    }
    Forbid() ;

    hdr = (struct MemHeader *) SysBase -> MemList . lh_Head ;

    while (hdr ->mh_Node.ln_Succ)
         {
        flag = *(char *)(hdr->mh_Node.ln_Name) ; /* 'F'ast or 'C'hip */

        for (chunk = hdr -> mh_First; chunk; chunk = chunk -> mc_Next)
                  {
            size = chunk -> mc_Bytes ;
            for (j = 0; size; j += 1)
                size >>= 1 ;

            Chunk_Count[j].kk += 1 ;
            if ( flag == 'e' )    /* count Fast or Chip chunks */
              ++Chunk_Count[j].fast ;
            else
              ++Chunk_Count[j].chip ;    /* GMD    */

        }

        hdr = (struct MemHeader *) hdr -> mh_Node . ln_Succ ;

      } /*end-while */

    Permit() ;

    Write(Output(), ghdr, (long)strlen(ghdr) ) ;    /* GMD */

    for (j = 1; j <= 23; ++j )
          {
        if (Chunk_Count[j].kk)
            print_count( j ) ;    /* print # of blocks    */
          }

        exit ( 0 ) ;            /* GMD         */
}

/***************************************************************************


  Name :          print_count

  Purpose:           Given index into array , prints line


  Entry    :


  Returns  :



****************************************************************************/



print_count ( j )

int j ;
{


    ascify ( (1L << (j-1)) ,             8 ,   &buffer[0]  ) ;
    ascify ( (long)Chunk_Count[j].kk ,   3 ,   &buffer[11] ) ;
    ascify ( (long)Chunk_Count[j].chip , 3 ,   &buffer[19] ) ;
    ascify ( (long)Chunk_Count[j].fast , 3 ,   &buffer[24] ) ;

    Write(Output(), buffer,(long)strlen(buffer) ) ;
}

/***************************************************************************


  Name :          ascify

  Purpose:      Converts a long number  to an ASCII string


  Entry    :    (long)numb = number
             (int) digs = # of digits to print ( field-width )
                (char *) where = ptr to where sting is to be copied


  Returns  :



****************************************************************************/


ascify ( numb , digs , where )

long numb ;
int digs ;
char *where ;

{
int j , k ;
char *ptr = where ;

    for ( j=0 , where += digs-1 ; j < digs ; ++j  )
       {
         k = numb%10 ;
         numb /= 10  ;
         *where-- = k + '0'  ;

       }
    while ( *ptr == '0' )
          *ptr++ = ' ' ;


}
/***************************************************************************


  Name :          MemCleanup

  Purpose:

 *
 * To cut down on memory useage, we provide a stub for a routine pulled
 * in by the default startup code in _main. This code cleans up
 * dynamically allocated memory, which we don't need. So we flush the code
 * here. By making this a smallcode, smalldata program, turning off stack
 * checking (nothing recursive, and only three routines, so who needs it?),
 * and adding this, I've reduced the size of MemFrag to 1644 bytes. Since the
 * original MemFrag is 1964 bytes long, I'm happy. Just out of curiosity, I'd
 * like to know how large a binary Manx 3.4 produces.


  Entry    :


  Returns  :



****************************************************************************/


MemCleanup() {}