Measuring your process memory usage

The .NET API allows you to retrieve the total amount of memory allocated to a process through the System.Diagnostics.Process class. This variable is useful is you are interested in the total memory footprint of your process, but it is too coarse to measure how much memory a single object takes.

long Process_MemoryStart = 0;
Process MyProcess = System.Diagnostics.Process.GetCurrentProcess();
Process_MemoryStart = MyProcess.PrivateMemorySize64;

This will return the total amount of memory uniquely allocated to your process in bytes (not shared with other processes).This measure of memory includes everything from code, libraries, the execution environment, stack, variables etc. If you try to measure the creation of a new object in memory using this variable it is likely to show no change.  It is very likely that the difference shown is zero as some memory for new objects is pre-allocated.

Using the garbage collector to gain insights into memory allocation

If you are building a multi threaded application the following code won’t work as expected, other threads might be too busy creating new objects and destroying to gain a clear insight into how much memory an object uses.We make use of the fact that the Garbage collector can report how much allocated memory it is aware off. As the Garbage collector manages just the objects we create for our application — we can use it to measure an objects size.

By calling System.GC.GetTotalMemory() we can obtain a measure of how much memory the Garbage collector is managing. If we call this function again after we allocated our object, we can calculate the difference.

// Measure starting point memory use
GC_MemoryStart = System.GC.GetTotalMemory(true);

// Allocate a new byte array of 20000 elements (about 20000 bytes)
MyByteArray = new byte[20000];

// Obtain measurements after creating the new byte[]
GC_MemoryEnd = System.GC.GetTotalMemory(true);

// Ensure that the Array stays in memory and doesn't get optimized away
MyByteArray[1] = 20;

By calling System.GC.GetTotalMemory with “true” as a parameter we ensure that the Garbage collector makes at least an efford to clean up before reporting the amount of memory under its management. To avoid any compiler optimizations that would shift code around, we need to make sure that our newly created byte array is accessed again after we make the second GetTotalMemory() call.

The code listed at the end of this post reports something similar to the following when run:

Memory Use reported by GC: 20480
Memory Use reported by Process: 65536
Memory allocated by the Garbage collector: 135168 bytes
Memory allocated by the process: 2641920 bytes

As you can see, allocating a 20,000 element byte array takes up about 20Kb (with some additional overhead). Apparently the garbage collector decided to increase the applications total memory by 64Kb as the total process size increased by that much.You mileage may vary depending on your run. The final two figures show how much memory is under management by the Garbage collector for our simple application (about 135Kb) and the how much the Operating system needed to allocate it the whole application (2 Megabyte).

using System;
using System.Diagnostics;

namespace ProfileTest
{
	class MainClass
	{
		public static void Main(string[] args)
		{
	      long GC_MemoryStart = 0;
    	  long GC_MemoryEnd = 0;
		  long Process_MemoryStart = 0;
		  long Process_MemoryEnd = 0;
		  byte[] MyByteArray;

		  Process MyProcess = System.Diagnostics.Process.GetCurrentProcess();

		  // Measure starting point memory use
      	  GC_MemoryStart = System.GC.GetTotalMemory(true);
		  Process_MemoryStart = MyProcess.PrivateMemorySize64;

		  // Allocate a new byte array of 20000 elements (about 20000 bytes)
		  MyByteArray = new byte[20000];

		  // Obtain measurements after creating the new byte[]
		  GC_MemoryEnd = System.GC.GetTotalMemory(true);
		  Process_MemoryEnd = MyProcess.PrivateMemorySize64;

		  // Ensure that the Array stays in memory and doesn't get optimized away
		  MyByteArray[1] = 20;

		  // Show the difference after allocating the memory
		  Console.WriteLine("Memory Use reported by GC: {0}" , GC_MemoryEnd - GC_MemoryStart );
		  Console.WriteLine("Memory Use reported by Process: {0}" , Process_MemoryEnd - Process_MemoryStart );

		  // Show how much memory was allocated by the process, and how much by the GC
		  Console.WriteLine("Memory allocated by the Garbage collector: {0} bytes", GC_MemoryEnd);
		  Console.WriteLine("Memory allocated by the process: {0} bytes", Process_MemoryEnd);
		}
	}
}

This is a post from Martijn's C# Coding Blog.

The complete source code is listed below, but lets have a little look at how it works first.

The problem

I want to take a string, and then encrypt it using a password. The result should be a Base64 encoded string that I can store somewhere relatively safe.

            // The message to encrypt.
            string Msg = "This world is round, not flat, don't believe them!";
            string Password = "secret";

            string EncryptedString = EncryptString(Msg, Password);
            string DecryptedString = DecryptString(EncryptedString, Password);

            Console.WriteLine("Message: {0}",Msg);
            Console.WriteLine("Password: {0}",Password);
            Console.WriteLine("Encrypted string: {0}",EncryptedString);
            Console.WriteLine("Decrypted string: {0}",DecryptedString);

In the EncryptString function we apply the TripleDES algorithm with a 128 bit key. But first we need to turn the above passphrase (’secret’) into a 128 bit key. One useful coincidence is that the MD5 hash algorithm accepts a set of bytes of any length and turns them into a 128 bit hash. So by running the password through the MD5 hashing algorithm we create our key.

            // Step 1. We hash the passphrase using MD5
            // We use the MD5 hash generator as the result is a 128 bit byte array
            // which is a valid length for the TripleDES encoder we use below

            MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
            byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(Passphrase));

The TripleDES algorithm itself turns a byte array into an encrypted byte array. So we first need to convert our C# message string (which is Unicode encoded) into a byte array through the System.Text.UTF8Encoding encoder.

The key is used to initialize the TripleDES algorithm. In addition we need to specify that we will only encode something once (CipherMode.ECB) and because its unlikely that our source string fits into a single TripleDES block we need to specify how we want to pad any remaining bytes (PaddingMode.PKCS7).

            // Step 2. Create a new TripleDESCryptoServiceProvider object
            TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();

            // Step 3. Setup the encoder
            TDESAlgorithm.Key = TDESKey;
            TDESAlgorithm.Mode = CipherMode.ECB;
            TDESAlgorithm.Padding = PaddingMode.PKCS7;

The encrypted byte array is finally converted into a Base64 encoded string for easy storage. The DecryptString function is very similar to the encryption function, except that it turns the Base64 encoded encrypted message back into the original UTF8 string.

Drawbacks to the above method

To keep the code above straightforward we made use of the fact that an MD5 hash is exactly 128 bits in length. The C# TripleDES code accepts three possible key lengths: 64 bit, 128 bit and 192 bit. Only 192 bit keys are truly TripleDES, the 128 bit key length we obtain from the MD5 hash is only sufficient for Double DES. According to Wikipedia, that would make its real key strength only equivalent to 80 bits.

The Source code

using System;
using System.Text;
using System.Security.Cryptography;

namespace EncryptStringSample
{
    class MainClass
    {

        public static string EncryptString(string Message, string Passphrase)
        {
            byte[] Results;
            System.Text.UTF8Encoding UTF8 = new System.Text.UTF8Encoding();

            // Step 1. We hash the passphrase using MD5
            // We use the MD5 hash generator as the result is a 128 bit byte array
            // which is a valid length for the TripleDES encoder we use below

            MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
            byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(Passphrase));

            // Step 2. Create a new TripleDESCryptoServiceProvider object
            TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();

            // Step 3. Setup the encoder
            TDESAlgorithm.Key = TDESKey;
            TDESAlgorithm.Mode = CipherMode.ECB;
            TDESAlgorithm.Padding = PaddingMode.PKCS7;

            // Step 4. Convert the input string to a byte[]
            byte[] DataToEncrypt = UTF8.GetBytes(Message);

            // Step 5. Attempt to encrypt the string
            try
            {
                ICryptoTransform Encryptor = TDESAlgorithm.CreateEncryptor();
                Results = Encryptor.TransformFinalBlock(DataToEncrypt, 0, DataToEncrypt.Length);
            }
            finally
            {
                // Clear the TripleDes and Hashprovider services of any sensitive information
                TDESAlgorithm.Clear();
                HashProvider.Clear();
            }

            // Step 6. Return the encrypted string as a base64 encoded string
            return Convert.ToBase64String(Results);
        }

        public static string DecryptString(string Message, string Passphrase)
        {
            byte[] Results;
            System.Text.UTF8Encoding UTF8 = new System.Text.UTF8Encoding();

            // Step 1. We hash the passphrase using MD5
            // We use the MD5 hash generator as the result is a 128 bit byte array
            // which is a valid length for the TripleDES encoder we use below

            MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
            byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(Passphrase));

            // Step 2. Create a new TripleDESCryptoServiceProvider object
            TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();

            // Step 3. Setup the decoder
            TDESAlgorithm.Key = TDESKey;
            TDESAlgorithm.Mode = CipherMode.ECB;
            TDESAlgorithm.Padding = PaddingMode.PKCS7;

            // Step 4. Convert the input string to a byte[]
            byte[] DataToDecrypt = Convert.FromBase64String(Message);

            // Step 5. Attempt to decrypt the string
            try
            {
                ICryptoTransform Decryptor = TDESAlgorithm.CreateDecryptor();
                Results = Decryptor.TransformFinalBlock(DataToDecrypt, 0, DataToDecrypt.Length);
            }
            finally
            {
                // Clear the TripleDes and Hashprovider services of any sensitive information
                TDESAlgorithm.Clear();
                HashProvider.Clear();
            }

            // Step 6. Return the decrypted string in UTF8 format
            return UTF8.GetString( Results );
        }

        public static void Main(string[] args)
        {
            // The message to encrypt.
            string Msg = "This world is round, not flat, don't believe them!";
            string Password = "secret";

            string EncryptedString = EncryptString(Msg, Password);
            string DecryptedString = DecryptString(EncryptedString, Password);

            Console.WriteLine("Message: {0}",Msg);
            Console.WriteLine("Password: {0}",Password);
            Console.WriteLine("Encrypted string: {0}",EncryptedString);
            Console.WriteLine("Decrypted string: {0}",DecryptedString);
        }
    }
}

This is a post from Martijn's C# Coding Blog.