auxprogs/malloc_test/malloc_test.c

//====================================================================================================
//$Header: /home/dashley/cvsrep/e3ft_gpl01/e3ft_gpl01/dtaipubs/cron/2010/blackjack_201010/source/auxprogs/malloc_test/malloc_test.c,v 1.7 2012/03/11 16:31:29 dashley Exp $
//====================================================================================================
//The purpose of this program is to ensure that the target system can allocate at least 1G of memory
//in fairly small chunks.
//
//This program was used to evaluate the Cygwin C development environment on my PC before beginning
//work on the "bjcceval" program.  It was determined the Cygwin will successfully allocate about 2G
//of memory.  This is more than adequate, and 1G is probably enough.  Systems that won't allow at
//least 1G to be allocated via malloc() may be problematic.  In any case, the "bjcceval" program
//will provide an error message if it runs out of memory (rather than a logical error affecting the
//results). 
//====================================================================================================
#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


#define ALLOC_CHUNK    (1024U)       //1K
#define ALLOC_NUM   (1048576U)       //1M
#define ITERATIONS     (1000U)

struct base_struct 
   {
   struct base_struct *next;
   void *chunk;
   };


typedef struct base_struct NODE;


int main(void)
   {
   unsigned i;
   unsigned iteration;
   NODE *head = NULL;
   NODE *cur  = NULL;

   //=================================================================================================
   //=================================================================================================
   //=================================================================================================
   printf("Execution begins.\n"); 

   //=================================================================================================
   //=================================================================================================
   //=================================================================================================
   printf("==============================================================================\n");
   printf("This program will attempt to allocate and deallocate about 1 gigabyte of\n");
   printf("dynamic memory using malloc() and free(), %u times.  This test should\n", ITERATIONS);
   printf("detect any gross anomalies in the computing environment.\n");
   printf("==============================================================================\n");
   printf("CVS version control information for the .c source file:\n   $RCSfile: malloc_test.c,v $\n   $Revision: 1.7 $\n   $Date: 2012/03/11 16:31:29 $\n");
   printf("==============================================================================\n");

   for (iteration = 0; iteration < ITERATIONS; iteration++)
      {
      printf("Iteration number %u/%u.\n", iteration+1, ITERATIONS);
      printf("Attempting to allocate %u elements of a linked list, each occupying %u bytes.\n",
             ALLOC_NUM,
             (unsigned)(sizeof(NODE) + ALLOC_CHUNK));

      for (i=1; i<=ALLOC_NUM; i++)
         {
         //Explain to the user what is going on.
         if ((i % 100000) == 0)
            {
            printf("   Allocating NODE number %u.\n", i);
            }

         //Allocate the NODE base.
         cur = malloc(sizeof(NODE));
         if (!cur)
            {
            printf("FAILURE:  Out of memory.\n");
            return(1);
            }

         //No child right now.
         cur->next = NULL;

         //Allocate the chunk.
         cur->chunk = malloc(ALLOC_CHUNK);
         if (!(cur->chunk))
            {
            printf("FAILURE:  Out of memory.\n");
            return(1);
            }

         //Write the chunk.  This is just to trigger an exception
         //hopefully if the allocation system of the target is somehow
         //defective.
         memset(cur->chunk, i, ALLOC_CHUNK);

         //Link the NODE into the list.
         if (!head)
            {
            //First one--easy.
            head = cur;
            }
         else
            {
            //Not the first one.
            cur->next = head;
            head = cur;
            }
         }

      //==============================================================================================
      //==============================================================================================
      //==============================================================================================
      //Count the nodes and walk them, just to be sure no surprises.
      printf("Counting nodes to be sure all accounted for ... ");

      i = 0;
      cur = head;

      while (cur)
         {
         i++;
         cur = cur->next;
         }

      if (i != ALLOC_NUM)
         {
         printf("\nFAILURE:  Node miscount.\n");
         return(1);
         }
      else
         {
         printf("OK.\n");
         }

      //==============================================================================================
      //==============================================================================================
      //==============================================================================================
      //Deallocate the nodes.
      printf("Deallocating nodes ... ");

      while (head)
         {
         cur = head;
         head = head->next;
         free(cur->chunk);
         free(cur);      
         }

      printf("OK.\n");
      printf("Test successful.\n");
      }

   return(0);
   }


//====================================================================================================
//$Log: malloc_test.c,v $
//Revision 1.7  2012/03/11 16:31:29  dashley
//Iterations increased to 1000.
//
//Revision 1.6  2012/03/11 16:30:35  dashley
//Minor changes.
//
//Revision 1.5  2012/03/11 16:29:24  dashley
//Version control information enhanced.
//
//Revision 1.4  2012/03/11 16:27:26  dashley
//Version control information added.
//
//Revision 1.3  2012/03/11 16:24:13  dashley
//Iterations added.
//
//Revision 1.2  2012/03/11 16:09:34  dashley
//Cosmetic edits.
//
//Revision 1.1  2012/03/11 15:26:09  dashley
//Initial checkin.
//====================================================================================================
//End of $RCSfile: malloc_test.c,v $.
//====================================================================================================
1	dashley	11	//====================================================================================================
2			//$Header: /home/dashley/cvsrep/e3ft_gpl01/e3ft_gpl01/dtaipubs/cron/2010/blackjack_201010/source/auxprogs/malloc_test/malloc_test.c,v 1.7 2012/03/11 16:31:29 dashley Exp $
3			//====================================================================================================
4			//The purpose of this program is to ensure that the target system can allocate at least 1G of memory
5			//in fairly small chunks.
6			//
7			//This program was used to evaluate the Cygwin C development environment on my PC before beginning
8			//work on the "bjcceval" program. It was determined the Cygwin will successfully allocate about 2G
9			//of memory. This is more than adequate, and 1G is probably enough. Systems that won't allow at
10			//least 1G to be allocated via malloc() may be problematic. In any case, the "bjcceval" program
11			//will provide an error message if it runs out of memory (rather than a logical error affecting the
12			//results).
13			//====================================================================================================
14			#include <malloc.h>
15			#include <stdio.h>
16			#include <stdlib.h>
17			#include <string.h>
18
19
20			#define ALLOC_CHUNK (1024U) //1K
21			#define ALLOC_NUM (1048576U) //1M
22			#define ITERATIONS (1000U)
23
24			struct base_struct
25			{
26			struct base_struct *next;
27			void *chunk;
28			};
29
30
31			typedef struct base_struct NODE;
32
33
34			int main(void)
35			{
36			unsigned i;
37			unsigned iteration;
38			NODE *head = NULL;
39			NODE *cur = NULL;
40
41			//=================================================================================================
42			//=================================================================================================
43			//=================================================================================================
44			printf("Execution begins.\n");
45
46			//=================================================================================================
47			//=================================================================================================
48			//=================================================================================================
49			printf("==============================================================================\n");
50			printf("This program will attempt to allocate and deallocate about 1 gigabyte of\n");
51			printf("dynamic memory using malloc() and free(), %u times. This test should\n", ITERATIONS);
52			printf("detect any gross anomalies in the computing environment.\n");
53			printf("==============================================================================\n");
54			printf("CVS version control information for the .c source file:\n $RCSfile: malloc_test.c,v $\n $Revision: 1.7 $\n $Date: 2012/03/11 16:31:29 $\n");
55			printf("==============================================================================\n");
56
57			for (iteration = 0; iteration < ITERATIONS; iteration++)
58			{
59			printf("Iteration number %u/%u.\n", iteration+1, ITERATIONS);
60			printf("Attempting to allocate %u elements of a linked list, each occupying %u bytes.\n",
61			ALLOC_NUM,
62			(unsigned)(sizeof(NODE) + ALLOC_CHUNK));
63
64			for (i=1; i<=ALLOC_NUM; i++)
65			{
66			//Explain to the user what is going on.
67			if ((i % 100000) == 0)
68			{
69			printf(" Allocating NODE number %u.\n", i);
70			}
71
72			//Allocate the NODE base.
73			cur = malloc(sizeof(NODE));
74			if (!cur)
75			{
76			printf("FAILURE: Out of memory.\n");
77			return(1);
78			}
79
80			//No child right now.
81			cur->next = NULL;
82
83			//Allocate the chunk.
84			cur->chunk = malloc(ALLOC_CHUNK);
85			if (!(cur->chunk))
86			{
87			printf("FAILURE: Out of memory.\n");
88			return(1);
89			}
90
91			//Write the chunk. This is just to trigger an exception
92			//hopefully if the allocation system of the target is somehow
93			//defective.
94			memset(cur->chunk, i, ALLOC_CHUNK);
95
96			//Link the NODE into the list.
97			if (!head)
98			{
99			//First one--easy.
100			head = cur;
101			}
102			else
103			{
104			//Not the first one.
105			cur->next = head;
106			head = cur;
107			}
108			}
109
110			//==============================================================================================
111			//==============================================================================================
112			//==============================================================================================
113			//Count the nodes and walk them, just to be sure no surprises.
114			printf("Counting nodes to be sure all accounted for ... ");
115
116			i = 0;
117			cur = head;
118
119			while (cur)
120			{
121			i++;
122			cur = cur->next;
123			}
124
125			if (i != ALLOC_NUM)
126			{
127			printf("\nFAILURE: Node miscount.\n");
128			return(1);
129			}
130			else
131			{
132			printf("OK.\n");
133			}
134
135			//==============================================================================================
136			//==============================================================================================
137			//==============================================================================================
138			//Deallocate the nodes.
139			printf("Deallocating nodes ... ");
140
141			while (head)
142			{
143			cur = head;
144			head = head->next;
145			free(cur->chunk);
146			free(cur);
147			}
148
149			printf("OK.\n");
150			printf("Test successful.\n");
151			}
152
153			return(0);
154			}
155
156
157			//====================================================================================================
158			//$Log: malloc_test.c,v $
159			//Revision 1.7 2012/03/11 16:31:29 dashley
160			//Iterations increased to 1000.
161			//
162			//Revision 1.6 2012/03/11 16:30:35 dashley
163			//Minor changes.
164			//
165			//Revision 1.5 2012/03/11 16:29:24 dashley
166			//Version control information enhanced.
167			//
168			//Revision 1.4 2012/03/11 16:27:26 dashley
169			//Version control information added.
170			//
171			//Revision 1.3 2012/03/11 16:24:13 dashley
172			//Iterations added.
173			//
174			//Revision 1.2 2012/03/11 16:09:34 dashley
175			//Cosmetic edits.
176			//
177			//Revision 1.1 2012/03/11 15:26:09 dashley
178			//Initial checkin.
179			//====================================================================================================
180			//End of $RCSfile: malloc_test.c,v $.
181			//====================================================================================================