I will give a brief account of how SQL Server memory is organized (in a nutshell). There is much more to it under the covers! 🙂
SQL Server Memory space is organized in the following manner:
Each instance of Microsoft SQL Server 2000 has an address space with two main components, each of which has several subcomponents:
There are two main areas of memory within SQL Server’s address space, the buffer pool (BPool) and a second memory pool sometimes called the “MemToLeave” area. The contents of the SQL Server buffer pool include cached table data, workspace memory used during query execution for in-memory sorts or hashes, most cached stored procedure and query plans, memory for locks and other internal structures, and the majority of other miscellaneous memory needs of the SQL Server. The Bpool handles memory allocations for 8K and below. All allocation requirements above 8K is satisfied from the MTL region.
- The number and size of the executable files and dynamic link libraries (DLLs) used by an instance of SQL Server varies over time. In addition to the executable files and DLLs used by Open Data Services, the SQL Server engine, and server Net-Libraries, the following components load in their own DLLs, and these DLLs can allocate memory themselves:
- Distributed queries can load an OLE DB Provider DLL on the server running the instance of SQL Server.
- Extended stored procedures are implemented as DLLs that are loaded into the address space of the instance of SQL Server.
- The OLE Automation system stored procedures are used to create instances of OLE Automation objects. Each class of OLE Automation object loads its own code into the address space of the instance of SQL Server.
The memory pool is the main unit of memory for an instance of SQL Server. Almost all data structures that use memory in an instance of SQL Server are allocated in the memory pool. The main types of objects allocated in the memory pool are:
System-level data structures
These are data structures that hold data global to the instance, such as database descriptors and the lock table.
This is the pool of buffer pages into which data pages are read.
This is a pool of pages containing the execution plans for all Transact-SQL statements currently executing in the instance.
Each log has a cache of buffer pages used to read and write log pages. The log caches are managed separately from the buffer cache to reduce the synchronization between log and data buffers. This results in fast, robust code.
Each connection has a set of data structures that record the current state of the connection. These data structures hold items such as parameter values for queries and stored procedures, cursor positioning information, and tables currently being referenced.
The high level memory architecture remains the same in SQL Server 2005 and 2008. The difference is that we introduced a change called Memory Clerks which were responsible for memory allocation requests for requirements for a particular object/cache store. The allocators changed to Single Page Allocator (any allocation required below 8KB) and Multi Page Allocator (any allocation above 8KB). With the help of SPA and MPA, we are now able to track Buffer Pool and non-Buffer Pool memory requests in a more structured manner when components within SQL Server are requesting for memory. However, if your DLL/CLR code hosted within SQL Server memory is calling VirtualAlloc() directly, then tracking those requires extensive data collection and analysis.
How to track SQL Server 2000 memory usage using DBCC Memorystatus
How to track SQL Server 2005 memory usage using DBCC Memorystatus
thank’s u post, i like this .Structured Settlement
Pingback: Common SQL Server myths – Series II – SQL Memory « TroubleshootingSQL