diff --git a/include/cmn/memPoolManager.h b/include/cmn/memPoolManager.h
new file mode 100644
index 0000000..61d614a
--- /dev/null
+++ b/include/cmn/memPoolManager.h
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2019, Infosys Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INCLUDE_CMN_MEMPOOLMANAGER_H_
+#define INCLUDE_CMN_MEMPOOLMANAGER_H_
+
+#include <cstdint>
+#include <memory>
+#include <cstring>
+
+namespace cmn {
+	namespace memPool {
+		template <typename T>
+		class MemBlock
+		{
+		public:
+                        union Data {
+                                MemBlock<T>* next_mp;
+                                alignas(alignof(T)) uint8_t dataBlock_m[sizeof(T)];
+                        };
+
+			MemBlock() { memset(data_m.dataBlock_m, 0, sizeof(T)); }
+
+			void reset() { memset(data_m.dataBlock_m, 0, sizeof(T)); }
+
+			MemBlock<T>* getNextMemBlock() { return data_m.next_mp; }
+			void setNextMemBlock(MemBlock<T>* nxtBlk_p) { data_m.next_mp = nxtBlk_p; }
+
+			T* getDataBlock() { return (reinterpret_cast<T*> (data_m.dataBlock_m)); }
+
+		private:
+			Data data_m;
+		};
+
+		template <typename T>
+		class MemChunk
+		{
+		public:
+
+			MemChunk(uint32_t numOfBlocks)
+			{
+				std::unique_ptr<MemBlock<T>[]> blkArray_p(new MemBlock<T>[numOfBlocks]);
+				blockArray_mpa.reset(blkArray_p.release());
+
+				uint32_t  i = 1;
+				for (; i < numOfBlocks; i++)
+				{
+					blockArray_mpa[i-1].setNextMemBlock(&blockArray_mpa[i]);
+				}
+				blockArray_mpa[i].setNextMemBlock(NULL);
+			}
+
+			MemBlock<T>* getMemBlockArray() { return blockArray_mpa.get(); }
+
+			void setNextMemChunk(std::unique_ptr<MemChunk> &&nxtChunk_p) { nextMemChunk_mp.reset(nxtChunk_p.release()); }
+
+		private:
+			std::unique_ptr<MemChunk<T>> nextMemChunk_mp;
+			std::unique_ptr<MemBlock<T>[]> blockArray_mpa;
+		};
+
+		template <typename T>
+		class MemPoolManager
+		{
+		public:
+			MemPoolManager(size_t chunkSize):chunkSize_m(chunkSize),
+					currentChunk_mp(new MemChunk<T>(chunkSize)),
+					freeList_mp(currentChunk_mp->getMemBlockArray())
+			{
+
+			}
+
+			template <typename... Args> T* allocate(Args &&... args)
+			{
+				if (freeList_mp == NULL)
+				{
+					std::unique_ptr<MemChunk<T>> newChunk_p (new MemChunk<T>(chunkSize_m));
+					newChunk_p->setNextMemChunk(std::move(currentChunk_mp));
+					currentChunk_mp.reset(newChunk_p.release());
+
+					freeList_mp = currentChunk_mp->getMemBlockArray();
+				}
+				MemBlock<T>* currentBlock_p = freeList_mp;
+				freeList_mp = freeList_mp->getNextMemBlock();
+
+				T* dataBlock_p = currentBlock_p->getDataBlock();
+
+				new (dataBlock_p) T(std::forward<Args>(args)...);
+				return dataBlock_p;
+			}
+
+			void free(T* data_p)
+			{
+			    data_p->T::~T();
+			    MemBlock<T>* currentBlock_p = reinterpret_cast<MemBlock<T>*>(data_p);
+			    
+			    currentBlock_p->reset();
+
+			    currentBlock_p->setNextMemBlock(freeList_mp);
+			    freeList_mp = currentBlock_p;
+			}
+		private:
+			size_t chunkSize_m;
+			std::unique_ptr<MemChunk<T>> currentChunk_mp;
+			MemBlock<T>* freeList_mp;
+		};
+	}
+}
+
+
+#endif /* INCLUDE_CMN_MEMPOOLMANAGER_H_ */