DZone Snippets: memory code

Reduce memory footprint of a .NET application

mstampar (Miroslav Stampar) — Sat, 02 Jun 2007 10:39:09 GMT

Don’t ask me anything. It just works :)



 try

{

Process process = Process.GetCurrentProcess();

process.MaxWorkingSet = loProcess.MaxWorkingSet;

process.Dispose();

}

catch { }

p.s. you can even make a timer that could run this piece of code periodically.

ActiveRecord each_by_page

duncanbeevers (Duncan Beevers) — Tue, 20 Feb 2007 23:59:50 GMT

Perform an operation on a set of models including ActiveRecord callbacks, without instantiating all models at once.

Step through and instantiate each member of the class and execute on it, but instantiate no more than per_page instances at any given time.
Safe for destructive actions or actions that modify the fields your :order or :conditions clauses operate on.



module ActiveRecord

  class Base

    def each_by_page per_page, options = {}, &block

      # By-id for model-modifying blocks

      # Build SQL to get ids of all matching records using the options provided by the user

      sql = construct_finder_sql(options.dup.merge({ :select => 'id' }))

      # Get the results as an array of tiny hashes { "id" => "1" } and flatten them out to just the ids

      all_ids = connection.select_all(sql).map { |h| h['id'] }

      at_a_time = 0..(per_page-1)

 

      # chop apart the all_ids array a segment at a time

      begin

        ids = all_ids.slice!(at_a_time)

        ids_cases = []

        ids.each_with_index { |id, i| ids_cases << "WHEN #{id} THEN #{i}" }

        ids_cases = ids_cases.join(' ')

 

        # Do the deed on this page of results

        find(:all, options.merge(

          :conditions => [ 'id IN (?)', ids ],

          :order => "CASE id #{ids_cases} END"

        )).each &block

 

      end until all_ids.empty?

    end

  end

end

link to blog entry

Unix Shared Memory

mackstann (Nick Welch) — Mon, 11 Sep 2006 12:40:12 GMT

If you want to use multiple blocks of shared memory in a single process
you might need to pass a different id to ftok() for each one. In any case,
the main entry point is open_shm(). It returns a block of shared memory
of the specified size. If justreading is 1, then you access what has been
written to that block of shared mem. If it's 0, then you create a new one
with undefined contents.

PDIE is left as an exercise to the reader...



/* This code written by Nick Welch , 2006.

 *

 * This code is in the public domain

 * and is provided AS IS, with NO WARRANTY. */



static key_t get_shm_key(void)

{

    /* both arbitrary */

    const char * KEY_PATH = "/dev/null";

    const char KEY_ID = 0xc4; 



    key_t key = ftok(KEY_PATH, KEY_ID);

    if (key == (key_t)-1)

        PDIE("ftok");



    return key;

}



static int get_shm_min(void)

{

    struct shminfo info;

    if((shmctl(0, IPC_INFO, (struct shmid_ds *)(void *)&info)) == -1)

        PDIE("shmctl (shminfo)");

    return info.shmmin;

}



static void * open_shm(size_t bytes, int justreading)

{

    void * shm;

    key_t key = get_shm_key();



    int id; 



    if(!justreading)

    {

        /* we need to delete it in case we need to allocate more memory this

         * time than last time.  if we try that without first deleting it, we

         * will get EINVAL.

         */



        id = shmget(key, get_shm_min(), 0644|IPC_CREAT);



        if(id == -1)

            PDIE("shmget (first call)");



        shm = shmat(id, NULL, 0);

        if (shm == NULL)

            PDIE("shmat(first call)");



        if(shmctl(id, IPC_RMID, NULL) == -1)

            PDIE("shmctl (marking shm segment for removal)");



        if(shmdt(shm) == -1)

            PDIE("shmdt (detaching shm segment to delete it)");

    }



    id = shmget(key, bytes, justreading ? 0 : 0644|IPC_CREAT);

    if(id == -1)

        PDIE("shmget (second call)");



    shm = shmat(id, NULL, 0);

    if (shm == NULL)

        PDIE("shmat (second call)");



    return shm;

}

C memory manager "MemoryBlock "

jonasraoni (Jonas Raoni Soares Silva) — Sat, 02 Jul 2005 03:53:59 GMT



//+ Jonas Raoni Soares Silva

//@ http://jsfromhell.com



#ifndef __MEMORYBLOCK__

#define __MEMORYBLOCK__





//-- includes -----------------------------------------------

#include 

#include 







//-- data types ---------------------------------------------

typedef struct _MemoryBlock {

	void *data;

	size_t capacity, used, dataSize;

}* MemoryBlock;







//-- functions ----------------------------------------------

MemoryBlock getMemoryBlock( register const size_t dataSize, register const size_t initialSize ){



	MemoryBlock mb = (MemoryBlock)malloc( sizeof( struct _MemoryBlock ) );

	

	if( mb ) {

		mb->used = 0;

		mb->data = NULL;

		mb->dataSize = dataSize;

		mb->capacity = initialSize && ( mb->data = (void *)malloc( initialSize * dataSize ) ) ? initialSize : 0;

	}

	return mb;

}



void freeMemoryBlock( register const MemoryBlock mb ){

	free( mb->data );

	free( mb );

}



int resizeMemoryBlock( register const size_t newSize, register const MemoryBlock mb ){



	void *newData = (void *)realloc( mb->data, newSize * mb->dataSize );



	if( newData ){

		mb->data = newData;

		return mb->capacity = newSize;

	}

	return 0;

}



int growMemoryBlock( register const MemoryBlock mb ){



	size_t delta = mb->capacity > 64 ? mb->capacity / 4 : mb->capacity > 8 ? 16 : 4;

	void *newData = (void *)realloc( mb->data, ( mb->capacity + delta ) * mb->dataSize );



	if( newData ){

		mb->data = newData;

		return mb->capacity += delta;

	}

	return 0;

}



int growExMemoryBlock( register const size_t neededBlocks, register const MemoryBlock mb ){

	while( mb->used+neededBlocks > mb->capacity )

		if( !growMemoryBlock( mb ) )

			return 0;

	return 1;

}



int incMemoryBlock( register const MemoryBlock mb ){

	return  mb->used+1 <= mb->capacity || growMemoryBlock( mb );

}



#endif