/**

Init:
=====

Es sollten 108080 Bytes Speicherplatz allokiert werden

Beim Programmstart:
===================

MemFree                5688260 kB
Delta MemFree          5688260 kB

MemAvail               6422760 kB
Delta MemAvail         6422760 kB

Nach dem Allokieren:
====================

MemFree                5687252 kB
Delta MemFree            -1008 kB

MemAvail               6421828 kB
Delta MemAvail            -932 kB

Nach dem Deallokieren:
======================

MemFree                5686760 kB
Delta MemFree             -492 kB

MemAvail               6421508 kB
Delta MemAvail            -320 kB

**/

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <unistd.h>

/***/

#define ZEILENLAENGE 256

char zeile [ZEILENLAENGE];

/***/

int anzahl_seiten = 0;

int zeilen_pro_seite = 0;

int zeichen_pro_zeile = 0;

char ***text = NULL;

/***/

int mem_free_neu, mem_free_alt = 0;

int mem_avail_neu, mem_avail_alt = 0;

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

void test_1 (void)
	{
	
	printf ("sizeof (*text)        %lu\n", sizeof (*text));
	printf ("sizeof (*text [0])    %lu\n", sizeof (*text [0]));
	printf ("sizeof (*text [0][0]) %lu\n", sizeof (*text [0][0]));
	printf ("\n");
	
	/**
	sizeof (*text)        8
	sizeof (*text [0])    8
	sizeof (*text [0][0]) 1
	**/	
	
	}
	
/*****************************************************************************/

void fehler (char *s)
	{
	puts (s);

	exit (EXIT_FAILURE);
	}

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

void init (void)
	{
	int i;
	
	char *p;
	
	anzahl_seiten = 10;
	
	zeilen_pro_seite = 100;
	
	zeichen_pro_zeile = 100;
	
	i = 	anzahl_seiten * zeilen_pro_seite * zeichen_pro_zeile * sizeof (char) +
	
		anzahl_seiten * zeilen_pro_seite * sizeof (p) +
	
		anzahl_seiten * sizeof (p);
		
	printf ("Init:\n");
	printf ("=====\n");
	printf ("\n");
	printf ("Es sollten %i Bytes Speicherplatz allokiert werden\n", i);	
	printf ("\n");
	}

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

void deallokiere_speicher (void)
	{
	int seite, zeile;
	
	if (text == NULL)
		printf ("deallokiere_speicher (): text == NULL\n");
		
	if (text != NULL)
		{
		
		/***/
		
		/// Zeilen
		
		for (seite = 0; seite < anzahl_seiten; seite++)
			for (zeile = 0; zeile < zeilen_pro_seite; zeile++)
				free (text [seite][zeile]);

		/// Seiten
		
		for (seite = 0; seite < anzahl_seiten; seite++)
			free (text [seite]);

		/// Text
		
		free (text);

		/***/
		
		anzahl_seiten = 0;
		
		zeilen_pro_seite = 0;
		
		zeichen_pro_zeile = 0;

		text = NULL;

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

void allokiere_speicher (void)
	{
	int seite, zeile;
	
	if (anzahl_seiten <= 0)
		fehler ("allokiere_speicher (): anzahl_seiten <= 0");
		
	if (zeilen_pro_seite <= 0)
		fehler ("allokiere_speicher (): zeilen_pro_seite <= 0");
		
	if (zeichen_pro_zeile <= 0)
		fehler ("allokiere_speicher (): zeichen_pro_zeile <= 0");
		
	if (text != NULL)
		printf ("allokiere_speicher (): text != NULL\n");
		
	if (text == NULL)
		{
		/// Seiten
		
		text = malloc (anzahl_seiten * sizeof (*text));
		
		/// Zeilen auf jeder Seite
		
		for (seite = 0; seite < anzahl_seiten; seite++)
			text [seite] = malloc (zeilen_pro_seite * sizeof (*text [0]));

		/// Zeichen in jeder Zeile auf jeder Seite

		for (seite = 0; seite < anzahl_seiten; seite++)
			for (zeile = 0; zeile < zeilen_pro_seite; zeile++)
				text [seite][zeile] = malloc (zeichen_pro_zeile * sizeof (*text [0][0]));
		}
	}
	
/*****************************************************************************/

void info (char *s)
	{
	const char dateiname [] = "/tmp/x.txt";

	int i;
	
	FILE *fp;
	
	/***/

	printf ("%s:\n", s);
	
	for (i = 0; i < strlen (s) + 1; i++)
		printf ("=");
	
	printf ("\n");
	printf ("\n");
	
	/***/

	sleep (1); /// Warten bis /proc/meminfo upgedatet wurde
	
	/***/

	strcpy (zeile, "cat /proc/meminfo | grep MemFree > ");
	
	strcat (zeile, dateiname);
	
	system (zeile);
	
	if ((fp = fopen (dateiname, "r")) == NULL)
		fehler ("Die Datei läßt sich nicht öffnen!");

	if (fscanf (fp, "%s %i", zeile, &mem_free_neu) != 2)
		fehler ("info () : MemFree : fscanf () != 2");
		
	fclose (fp);

	/***/

	strcpy (zeile, "cat /proc/meminfo | grep MemAvailable > ");
	
	strcat (zeile, dateiname);
	
	system (zeile);
	
	if ((fp = fopen (dateiname, "r")) == NULL)
		fehler ("Die Datei läßt sich nicht öffnen!");

	if (fscanf (fp, "%s %i", zeile, &mem_avail_neu) != 2)
		fehler ("info () : MemAvail : fscanf () != 2");
		
	fclose (fp);

	/***/
	
	printf ("MemFree        %15i kB\n", mem_free_neu);
	printf ("Delta MemFree  %15i kB\n", mem_free_neu - mem_free_alt);
	printf ("\n");

	mem_free_alt = mem_free_neu;
	
	/***/
	
	printf ("MemAvail       %15i kB\n", mem_avail_neu);
	printf ("Delta MemAvail %15i kB\n", mem_avail_neu - mem_avail_alt);
	printf ("\n");

	mem_avail_alt = mem_avail_neu;
	
	/***/
	
	}
	
/*****************************************************************************/

void test (void)
	{
	
	/***/

	init ();
	
	/***/

	info ("Beim Programmstart");
	
	/***/
	
	allokiere_speicher ();

	///atexit (deallokiere_speicher);
	
	info ("Nach dem Allokieren");
	
	/***/
	
	deallokiere_speicher ();

	info ("Nach dem Deallokieren");
	
	/***/

	if (0)
		{
		printf ("Wenn \"deallokiere_speicher ()\" \"atexit\" nochmal aufgerufen wird, kommt jetzt eine Fehlermeldung!\n");
		
		printf ("\n");
		}
		
	/***/
	
	}

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

int main (int argc, char **argv)
	{
	printf ("Hello, world\n\n");

	test ();

	return EXIT_SUCCESS;
	}