Performance programming for WebSphere eXtreme Scale Client for .NET

IGridMapPessimisticAutoTx API versus IGridMapPessimisticTx API

IGridMapPessimisticAutoTx<object,object> autoTxMap = 
	grid.GetGridMapPessimisticAutoTx<object,object>("Map");
IGridMapPessimisticTx<object,object> manualTxMap = 
	grid.GetGridMapPessimisticTx<object,object>("Map");                

// 1 remote grid access        
object autoVal = autoTxMap.Get(key);

// 2 remote grid accesses
manualTxMap.Transaction.Begin();
object manualVal = manualTxMap.Get(key); // first remote grid access to get and lock item
manualTxMap.Transaction.Commit();    	     // second remote grid access to release the shared lock

Batch APIs

• IGridMapPessimisticAutoTx.GetAll, IGridMapPessimisticTx.GetAll
• IGridMapPessimisticAutoTx.InvalidateAll, IGridMapPessimisticTx.InvalidateAll
• IGridMapPessimisticAutoTx.PutAll, IGridMapPessimisticTx.PutAll
• IGridMapPessimisticAutoTx.RemoveAll, IGridMapPessimisticTx.RemoveAll
• IGridMapPessimisticTx.LockAll
• IGridMapPessimisticTx.GetAndLockAll

• IGridMapPessimisticAutoTx.ContainsKeyAll, IGridMapPessimisticTx.ContainsKeyAll
• IGridMapPessimisticAutoTx.AddAll, IGridMapPessimisticTx.AddAll
• IGridMapPessimisticAutoTx.ReplaceAll, IGridMapPessimisticTx.ReplaceAll
• IGridMapPessimisticAutoTx.TouchAll, IGridMapPessimisticTx.TouchAll

Pooling data grid and map objects

.NET application processor and memory usage increase when you instantiate IGrid, IGridMapPessimisticAutoTx, and IGridMapPessimisticTx objects.  Where possible, maintain the minimum number of these instances.  Grid objects are thread safe. A single instance can be shared across all threads in the process.  Map objects, such as IGridMapPessimisticAutoTx and IGridMapPessimisticTx objects, are not thread safe, so each concurrent thread requires a separate map object instance.  If your .NET application accesses the data grid from many different threads, maintain a thread-accessible pool of map object instances. This pool prevents the constant recreation of map instances.  The following code sample shows a map instance pool implementation:

using System;
using System.Collections.Concurrent;
using System.Threading;
using IBM.WebSphere.Caching; 
using IBM.WebSphere.Caching.Map;  
namespace NetClientPooledMapExample 
{     
	class Program     
	{         
		private static ConcurrentQueue<IGridMapPessimisticAutoTx<string, string>> autoTxMapQ = 
			new ConcurrentQueue<IGridMapPessimisticAutoTx<string, string>>();         
		private static IGridManager gm = null;         
		private static ICatalogDomainInfo cdi = null;         
		private static IClientConnectionContext ctx = null;         
		private static IGrid g = null;          
		static void Main(string[] args)         
		{             
			int numThreads = 50;    // Number of concurrent threads accessing the same map              
			try             
			{                 
				gm = GridManagerFactory.GetGridManager();
				cdi = gm.CatalogDomainManager.CreateCatalogDomainInfo("localhost:2809");                 
				ctx = gm.Connect(cdi);
				g = gm.GetGrid(ctx, "Grid");                  
				Thread[] tArray = new Thread[numThreads];                 
				for (int i = 0; i < numThreads; i++)                 
				{                     
					tArray[i] = new Thread(PopulateGrid);                     
					tArray[i].Start();                 
				}                  
				for (int i = 0; i < numThreads; i++)                 
				{                     
					tArray[i].Join();                 
				}             
			}             
			catch (Exception e)          
			{                 
				Console.WriteLine("Encountered exception during grid access: {0}", e);             
			}             
			finally             
			{                 
				if (gm != null &amp;&amp; ctx != null)                 
				{                     
					gm.Disconnect(ctx);                 
				}             
			}         
		}          
		private static void PopulateGrid()         
		{             
			IGridMapPessimisticAutoTx<string, string> gridMapAuto = null;             
			string key = "Key_" + Thread.CurrentThread.ManagedThreadId;             
			string value = "Val_" + Thread.CurrentThread.ManagedThreadId;              
			try             
			{                 
				// Pull an available map off the queue                 
				gridMapAuto = GetAutoTxMap(g, "Map1");                  
				// Do some work with the map                 
				gridMapAuto.Put(key, value);                  
				Console.WriteLine("Thread {0} wrote key {1} with value {2}", 
					Thread.CurrentThread.ManagedThreadId, key, value);             
			}             
			catch (Exception e)             
			{                 
				Console.WriteLine("Encountered exception during map access: {0}", e);             
			}             
			finally             
			{                 
				// Release the map to the queue when done                
				ReleaseAutoTxMap(gridMapAuto);             
			}         
		}          
		private static IGridMapPessimisticAutoTx<string, string> GetAutoTxMap(IGrid grid, string mapName)         
		{             
			IGridMapPessimisticAutoTx<string, string> retmap = null;              
			if (!autoTxMapQ.TryDequeue(out retmap))             
			{                 
				// Create a new map if the queue is out of available maps                 
				retmap = grid.GetGridMapPessimisticAutoTx<string, string>(mapName);             
			}              
			return retmap;         
		}          
		private static void ReleaseAutoTxMap(IGridMapPessimisticAutoTx<string, string> map)         
		{             
			autoTxMapQ.Enqueue(map);         
		}      
	} 
} 

.NET ThreadPool management