博客园_永恒的青春

日志文件如何影响我数据库的启动

2012-02-03T08:56:00Z

原文：http://blogs.msdn.com/b/apgcdsd/archive/2011/12/30/10251946.aspx

截取一段，备查
日志文件如何影响我数据库的启动？

无论你的SQL Server启动，或者你将某数据库重备份中恢复，或者其他的一些情况，总之在你的数据库能够被正常使用之前，你的数据库都会进入 Recovery的状态。http://msdn.microsoft.com/en-us/library/ms190442.aspx 如果这一个步失败，那么你的数据库就会进入Suspect状态而无法正常使用。在一些特殊情况下，这个Recovery所花费的时间会很长。在数据库进入Online状态之前，我们都不能认为SQL Server可以被正常使用了。

那么在Recovery中做了什么呢？

我们可以在你的SSMS中运行如下语句。在运行之前，你可以先按下Ctrl+T来把结果转化成Plain Text格式。

sp_readerrorlog会返回自从最近一次SQL Server服务启动，或者Error Log被回收开始的SQL Server的Error Log信息。这里有两个词汇可能会让你感到疑惑。首先，这里的Log和我们上文所说的日志文件（Transaction Log）中的Log不是一件事情。其次，所谓的Error Log，并不是说这里出现了Error。SQL Server使用这个Error Log记录了很多诊断信息。所以，你可以认为这只是一个普通的记录了很多SQL Server相关信息的日志文件。

在结果返回中，你可能会找到上面的这些信息。引号中为在你当前数据库实例下的各个数据库名。

以数据库‘CaseLync’为例。由于Error Log会记录当前SQL Server实例下的所有数据库的相关信息，所以你可能会看到和这个数据库相关的日志被顺序地分布在日志的不同地方。在上图中，第一和第二行提及两个词：rolled forward和rolled back。这两个词和我们本文中所提及的Transaction Log息息相关。

在前文中，我们提到过数据修改的过程：先同步的被写入Transaction Log，然后再Checkpoint发生的时候被同步到Data File里。那么，如果我的事物（Transaction）没有被提交（Commit）或者回滚（Rollback），那么这个数据修改是否也在日志文件（Transaction Log）还是在数据文件里（Data File）？

答案是：都在！

SQL Server在记录数据改变时，并不会区分该语句是否有显示的进行事物操作（Begin Transaction，Commit / Rollback Transaction）, 或者该事务是否有完成。SQL Server会忠实地记录所有的修改操作。而Begin Transaction和Commit / Rollback Transaction本身也是日志文件需要记录的操作之一。

由于对于事物日志的修改要先于对于数据文件的修改，所以当你的数据库处于Recovery的状态时，那么Transaction Log就会从最近的一个Checkpoint点开始做如下操作：

如果该操作已在在Transaction Log中，而不在Data File之中，并且如果它使用显式的Transaction操作符而且处于Commit状态，则会发生一次Rolled Forward操作，将该操作同步到Data File之中。
如果该操作已在在Transaction Log中，而不在Data File之中，并且如果它使用显式的Transaction操作符而且处于Rollback Transaction状态，则会发生一次Rolled back操作，将Data File之中的相关数据修改回滚到Transaction发生之前。
如果该操作已在在Transaction Log中，而不在Data File之中，并且如果它使用显式的Transaction在日志文件中即没有Commit操作，也没有Rollback操作，则会发生一次Rolled back操作，将Data File之中的相关数据修改回滚到Transaction发生之前。
如果该操作已在在Transaction Log中，而不在Data File之中，并且如果它没有使用显式的Transaction操作符（Begin Transaction）, 则被认为是一个Rolled Forward操作。
如上步骤都完成后，SQL Server会对该数据库做一个Checkpoint的标识，并写入Transaction Log，表示Data File和Transaction Log已经同步。这表明了数据库的Recovery完成。数据库将进入Online状态，并被正常使用。如果你的数据库在最近的一次Checkpoint到现今的修改操作足够多，在Error Log中也会看到SQL Server用百分比标识Recovery完成的进展。

本文链接

How can I create a dump of SQL Server?

2012-02-01T06:58:00Z

原文：http://blogs.msdn.com/b/askjay/archive/2010/02/05/how-can-i-create-a-dump-of-sql-server.aspx

You can create a memory dump of the SQL Server process space in several ways. There are many external tools that can help you accomplish this such as userdump.exe, debugdiag.exe, and ADPlus.exe. In this post, I’ll cover 3 common ways to accomplish this for SQL Server: The most common way (sqldumper), using the debugger, and three methods from within SQL Server itself.

First, two of these methods will require that you get the process id (PID) of SQL Server. Here are a few simple ways to do that:

1. From a command window, execute --> tasklist | find /i “sqlservr” or from the Debugging tools directory execute –> tlist | find /i “sqlservr”

2. Open task manager, and find sqlservr.exe and get the PID from the PID column. If you don’t see this column, then select View –> Select Columns to add it.

3. In a query window inside of SSMS on the instance you wish to dump, execute –> “SELECT SERVERPROPERTY(‘PROCESSID’)

4. Get the process ID from the SQL Server Errorlog.

Now that you have the PID, you can use one of the following ways to create the dump:

Method 1 (Using SqlDumper)

The most common way (and the way used internally by SQL Server) is to run SqlDumper.exe. You will find SqlDumper.exe in the following directory for a default installation of SQL Server:

C:\Program Files\Microsoft SQL Server\100\Shared

The syntax of SqlDumper is as follows:

SqlDumper <process id (PID)> <thread id (TID)> <Flags:Minidump Flags> <SQLInfoPtr> <Dump Directory>

more parameters can be seen with SqlDumper /?

The common flags are as follows:

0x0120 – Minidump (this is a dump of just the stacks and loaded modules – this is the smallest of the dump types – this is normally the type of dump created automatically by SQL Server during AVs and other exceptions)

0x01100 – Full Dump (this dumps the entire process space – this can be very large on a 64 bit system or any system with a large amount of memory assigned to SQL Server)

0x8100 – Filtered Dump (a filtered dump is a dump of all of Stolen Memory plus certain areas of the buffer pool)

NOTICE: SQLDumper can be used to dump ANY user mode process – not just SQL Server.

Some examples for SQLServer running under SPID 4024 to c:\temp:

Minidump: sqldumper 4024 0 0x0120 0 c:\temp
Full Dump: sqldumper 4024 0 0x01100 0 c:\temp
Filtered Dump: sqldumper 4024 0 0x8100 0 c:\temp

The dump file will have the naming convention of: SQLDmpr####.mdmp (i.e. SQLDmpr0001.mdmp)

Method 2 (Using a debugger)

To dump SQL Server from WINDBG or other debugger, attach the debugger to the process using the PID:

Once connected, just use the .dump command which has the following syntax:

Options are:
/a - Create dumps for all processes (requires -u)
/b[a] - Package dump in a CAB and delete dump
/c <comment> - Add a comment (not supported in all formats)
/j <addr> - Provide a JIT_DEBUG_INFO address
/f - Create a legacy style full dump
/m[acdfFhiprRtuw] - Create a minidump (default)
/o - Overwrite any existing file
/u - Append unique identifier to dump name

“.dump /ma” is the recommend method of creating a complete memory dump of a user mode process.

So, to create a complete memory dump of the SQL Server to c:\temp, execute the following:

.dump /ma c:\temp\sqldump.dmp

Method 3 (From within SQL Server)

From inside SQL Server, you can create a dump using two different methods. First, to create a manual dump immediately, use the following undocumented command:

DBCC STACKDUMP

This will create a memory dump in the LOG directory of your SQL Server instance installation. To enable this method to create a FULL DUMP, you must turn on trace flags 2544 and 2546:

dbcc traceon(2544, -1)
go

dbcc traceon(2546, -1)
go

dbcc stackdump

To create only a minidump, enable trace flag 2546. To create a full-filtered dump, use trace flag 2551.

You can use the undocumented DBCC DUMPTRIGGER command to enable SQL Server to create a dump on the occurrence of an error. You can use the following to enable a full dump on error 802 (There is insufficient memory available in the buffer pool):

-- turn on TFs for full dump
dbcc traceon(2544, -1)
go
dbcc traceon(2546, -1)
go

-- set DUMP TRIGGER for exception 802
dbcc dumptrigger('set', 802)
go

-- view exceptions set for DUMP TRIGGER
dbcc traceon(3604, -1)
go
dbcc dumptrigger('display')
go
dbcc traceoff(3604, -1)
go

-- Turn off dumptrigger for exception 802
dbcc dumptrigger('clear', 802)
go

Finally, you can also use the –y parameter on SQL Server startup to achieve the same functionality as SQL Server’s DBCC DUMPTRIGGER. For more information refer to:

http://blogs.msdn.com/psssql/archive/2008/01/10/how-it-works-sql-server-engine-error-messages.aspx

One method not covered in this post is to create the dump from within Task Manager as seen here:

I am not a big fan of this method since you have little control over it. It will create a full dump inside your user profile by default. It is also only available on Windows 2008 and Windows 2008 R2 (or Vista and Windows 7). However, it is yet another way to dump the SQL Server process.

- Jay

本文链接

在发布订阅中增加rowversion数据类型字段引发错误(or bug)

2011-12-01T05:19:00Z

考虑这样的场景，现在每天要同步更新的数据，为了记录哪些数据发生过变更，需要对表添加一个rowversion列来标识被更新过。恰好这个表比较大，而且有发布订阅。由于该字段对于订阅表来讲，无实际意义，而且添加一个有默认值的不可为空的8字节字段，会产生数据空间分配，或许带来大量的页拆分，对IO压力会加大，所以考虑将此表的发布项暂时改为不支持架构复制，等添加完该字段后，再将其改为支持架构复制。

下面来做这个测试：

1.下面是一个正常的事务发布，将DB_1中的T_1发布到DB_2的T_1表中。

2.修改发布项DBrepTEST关于架构复制的选项，设置为不支持

DECLARE @publication AS sysname
SET @publication = N'DBrepTEST' 

USE DB_1
EXEC sp_changepublication 
  @publication = @publication, 
  @property = N'replicate_ddl', 
  @value = 0
GO

3.然后，添加一个字段，类型为rowversion

use DB_1
alter table t_1 add rv rowversion

4.经过观察，发布订阅一切正常，该字段并未被创建在订阅库DB_2上

5.我们在另外一个进程开始一个sql，向表DB_1.dbo.T_1 insert data.

while 1=1
begin
waitfor delay '00:00:01'
insert into DB_1.dbo.T_1(name)select 'a'
end

6.发现数据已同步到DB_2.dbo.T_1，但rv字段并未被同步，现在一切正常

7.现在将发布项DBrepTEST修改回支持架构复制

DECLARE @publication AS sysname
SET @publication = N'DBrepTEST' 

USE DB_1
EXEC sp_changepublication 
  @publication = @publication, 
  @property = N'replicate_ddl', 
  @value = 1
GO

8.然后，此时向表DB_1.dbo.T_1新加一个int类型字段

use DB_1
go
alter table t_1 add age int

9.此时发布订阅出错

出错文字为：
Command attempted:
if @@trancount > 0 rollback tran
(Transaction sequence number: 0x000000580000013C000100000000, Command ID: 6)

Error messages:
A DDL change has been replicated. (Source: MSSQL_REPL, Error number: MSSQL_REPL27332)
Get help: http://help/MSSQL_REPL27332
列名 'rv' 无效。 (Source: MSSQLServer, Error number: 207)
Get help: http://help/207
10.由上面的信息，可以看出此时是由于在订阅库上找不到rv这个列造成的，为了确定这一点，我们看下这个事务执行的是什么

use distribution
go
EXEC sp_browsereplcmds '0x000000580000013C000100000000','0x000000580000013C000100000000'

11.由10的结果中的command列，得到如下需要应用到订阅库的t-sql

ALTER TABLE [dbo].[T_1] add age int
if object_id(N'[dbo].[sp_MSins_dboT_1]', 'P') > 0      drop proc [dbo].[sp_MSins_dboT_1] 
 -- 
if object_id(N'dbo.MSreplication_objects') is not null      delete from dbo.MSreplication_objects where object_name = N'sp_MSins_dboT_1' 
 -- 
create procedure [dbo].[sp_MSins_dboT_1] 
    @c1 int, 
    @c2 varchar(20), 
    @c3 int 
as 
begin   
 insert into [dbo].[T_1]( 
  [id], 
  [name], 
  [rv], 
  [age] 
 ) values ( 
    @c1, 
    @c2, 
    default, 
    @c3 )  
end   
 -- 
if columnproperty(object_id(N'dbo.MSreplication_objects'), N'article', 'AllowsNull') is not null  exec sp_executesql       @statement =           N'insert dbo.MSreplication_objects (object_name, publisher, publisher_db, publication, article, object_type)               values           (@object_name, @publisher, @publisher_db, @publication, @article, ''P'')',      @parameters =           N'@object_name sysname, @publisher sysname, @publisher_db sysname, @publication sysname, @article sysname',      @object_n
ame = N'sp_MSins_dboT_1',      @publisher = N'mySrv\SQL2008',      @publisher_db = N'DB_1',      @publication = N'DBrepTEST',      @article = N'T_1' 
 -- 
 --
if object_id(N'[dbo].[sp_MSdel_dboT_1]', 'P') > 0      drop proc [dbo].[sp_MSdel_dboT_1] 
 -- 
if object_id(N'dbo.MSreplication_objects') is not null      delete from dbo.MSreplication_objects where object_name = N'sp_MSdel_dboT_1' 
 -- 
create procedure [dbo].[sp_MSdel_dboT_1] 
    @pkc1 int  as  begin   
 delete [dbo].[T_1]  where [id] = @pkc1 
if @@rowcount = 0      if @@microsoftversion>0x07320000          exec sp_MSreplraiserror 20598 
end   
 -- 
if columnproperty(object_id(N'dbo.MSreplication_objects'), N'article', 'AllowsNull') is not null  exec sp_executesql       @statement =           N'insert dbo.MSreplication_objects (object_name, publisher, publisher_db, publication, article, object_type)               values           (@object_name, @publisher, @publisher_db, @publication, @article, ''P'')',      @parameters =           N'@object_name sysname, @publisher sysname, @publisher_db sysname, @publication sysname, @article sysname',      @object_n
ame = N'sp_MSdel_dboT_1',      @publisher = N'mySrv\SQL2008',      @publisher_db = N'DB_1',      @publication = N'DBrepTEST',      @article = N'T_1' 
 -- 
 --
if object_id(N'[dbo].[sp_MSupd_dboT_1]', 'P') > 0      drop proc [dbo].[sp_MSupd_dboT_1] 
 -- 
if object_id(N'dbo.MSreplication_objects') is not null      delete from dbo.MSreplication_objects where object_name = N'sp_MSupd_dboT_1' 
 -- 
create procedure [dbo].[sp_MSupd_dboT_1] 
    @c1 int = NULL, 
    @c2 varchar(20) = NULL, 
    @c3 int = NULL, 
    @pkc1 int = NULL, 
    @bitmap binary(1)  as  begin   
update [dbo].[T_1] set 
    [name] = case substring(@bitmap,1,1) & 2 when 2 then @c2 else [name] end, 
    [age] = case substring(@bitmap,1,1) & 4 when 4 then @c3 else [age] end  where [id] = @pkc1 
if @@rowcount = 0      if @@microsoftversion>0x07320000          exec sp_MSreplraiserror 20598 
end  
 -- 
if columnproperty(object_id(N'dbo.MSreplication_objects'), N'article', 'AllowsNull') is not null  exec sp_executesql       @statement =           N'insert dbo.MSreplication_objects (object_name, publisher, publisher_db, publication, article, object_type)               values           (@object_name, @publisher, @publisher_db, @publication, @article, ''P'')',      @parameters =           N'@object_name sysname, @publisher sysname, @publisher_db sysname, @publication sysname, @article sysname',      @object_n
ame = N'sp_MSupd_dboT_1',      @publisher = N'mySrv\SQL2008',      @publisher_db = N'DB_1',      @publication = N'DBrepTEST',      @article = N'T_1' 
 -- 
 --

可以看到对于添加字段，会重新创建对表操作的三个proc，本例中，insert这个proc会将rv加入进来，并且值为default,如下所示，但由于该列并不存在于订阅中，所以就会报错了，由此造成分发中断，后续事务无法应用到订阅端。

create procedure [dbo].[sp_MSins_dboT_1] 
    @c1 int, 
    @c2 varchar(20), 
    @c3 int 
as 
begin   
 insert into [dbo].[T_1]( 
  [id], 
  [name], 
  [rv], 
  [age] 
 ) values ( 
    @c1, 
    @c2, 
    default, 
    @c3 )

12.虽然可以通过在订阅端手工端建一个rv列，将其设置为可为null的varbinary(8)类型，但这个列对于订阅并没有实际意义。

use DB_2
go
alter table t_1 add rv varbinary(8)

总结，经过测试，发现当添加其它类型字段，并设置为有默认值且not null时，不会有此错误出现，目前发现仅是rowversion类型列，不知是否为SQL Server bug.
测试环境：windows server 2003 enterprise 32bit sql server 2008 sp2 standard 32bit

本文链接

[荐][转]SQL SERVER SQLOS的任务调度

2011-11-28T03:03:00Z

【介绍】

SQL Server 通过WORKER, SCHEDULER, TASK等来对任务进行调度和处理。了解这些概念，对于了解SQL Server 内部是如何工作，是非常有帮助的。

通常来讲，SCHEDULER个数是跟CPU个数相匹配的。除了几个系统的SCHEDULER以外，每一个SCHEDULER都映射到一个CPU，如下面的查询结果所示，我们有四个CPU，也就有相应四个SCHEDULER。

而WORKER (又称为WORKER THREAD), 则是工作线程。在一台服务器上，我们可以有多个工作线程。因为每一个工作线程要耗费资源，所以，SQL Server有一个最大工作线程数。一个TASK进来，系统会给它分配一个工作线程进行处理。但是当所有的工作线程都在忙，而且已经达到了最大工作线程数，SQL Server就要等待，直到有一个忙的工作线程被释放。最大工作线程数可以通过下面的查询得到。SQL SERVER并不是一开始就把这些所有的工作线程都创建，而是依据需要而创建。

TASK是由BATCH而来。我们知道，一个连接，可以包含多个BATCH，而每个BATCH则可以分解成多个TASK。如下面某一个连接要做的事情。这个连接要做的有两个BATCH，而每个BATCH，如SELECT * FROM TABLE_B，因为可以支持并行化查询，所以可能会被分解成多个TASK。具体BATCH怎么分解成TASK，以及分解成多少个，则是由SQL Server内部决定的。

INSERT INTO TABLE_B VALUES (‘aaa’)
GO
SELECT * FROM TABLE_B
GO

【关系】

我们初步了解了Connection, Batch, Task, Worker, Scheduler, CPU这些概念，那么，它们之间的关系到底是怎么样呢？

如上图所示，左边是很多连接，每个连接有一个相应的SPID，只要用户没有登出，或者没有timeout, 这个始终是存在的。标准设置下，对于用户连接数目，是没有限制的。

在每一个连接里，我们可能会有很多batch，在一个连接里，batch都是按顺序的。只有一个batch执行完了，才会执行下面一个batch。因为有很多连接，所以从SQL Server层面上看，同时会有很多个batch。

SQL Server会做优化，每一个batch，可能会分解成多个task以支持如并行查询。这样，在SQL层面上来看，同时会有很多个TASK。

SQL Server 上，每一个CPU通常会对应一个Scheduler, 有几个额外的系统的Scheduler，只是用来执行一些系统任务。对用户来讲，我们只需要关心User Scheduler就可以了。如果有4个CPU的话，那么通常就会有4个User Scheduler。

每个Scheduler上，可以有多个worker对应。Worker是真正的执行单元，Scheduler（对CPU的封装）是执行的地方。Worker的总数受max worker thread限制。每一个worker在创建的时候，自己需要申请2M内存空间。如果max worker thread为1024，并且那些worker全部创建的话，至少需要2G空间。所以太多的worker，会占用很多系统资源。

【跟踪】

我们了解了Connection, Batch, Task, Worker, Scheduler, CPU之间的关系，下面我们用DMV跟踪一下运作的流程。

步骤一：

执行下面的脚本，创建一个测试数据库和测试数据表

CREATE DATABASE TEST
go
use TEST
go

CREATE TABLE TEST
(ID int,
name nvarchar(50)
)
INSERT INTO TEST VALUES (1, 'aaa')

步骤二：
打开一个查询窗口，执行下面的语句，注意，我们这里并没有commit transaction.

begin tran
update TEST set name='bbb' where [ID] = 1

步骤三：
打开另外一个窗口，执行下面的语句，我们会看到，下面的查询会一直在执行，因为我们前面的一个transaction并没有关闭。从查询窗口，我们可以看到，下面语句执行的SPID为58

SELECT * FROM TEST

步骤四：查看连接。

从下面的查询来看，我们的连接对应的SPID是58，被block住了。

步骤五：查看batch

我们查看SQL Profiler, 看到我们的Batch是SELECT * FROM TEST

步骤六：查看TASK

用下面的DMV, 我们可以看到，针对SESSION_ID=58的，只有一个task. (地址为0x0064F048), 而针对该TASK的worker地址为: 0x803081A0。同时我们也可以看到该worker运行在Scheduler 0上面。

步骤七：查看WORKER

从下面的查询可以知道，这个WORKER已经执行了5291个task了。这个worker相应的Scheduler地址是0x00932080

步骤八：查看SCHEDULER

从下面的查询可以得知，Scheduler_address (0x00932080) 相应的CPU_ID是0。在我们的系统上，有4个CPU, 编号分别为0， 1， 2， 3. 但是有7个SCHEDULER, 其中3个是SYSTEM SCHEDULER, 4个是USER SCHEDULER。在每个SCHEDULER上，有相应的WORKER数目。因为WORKER是根据需要而创建的，所以，在每个SCHEDULER上，目前WORKER数目很少。而且其中有些WORKER还处于SLEEPING状态。

【应用】

我们了解了SQL SERVER任务调度的机制，那么有些问题，就会更加清楚。

设置MAXDOP的作用。MAXDOP=1的话，可以使得一个BATCH只对应一个TASK。如果一个BATCH产生多个TASKS，那么TASK之间的协调，等待等等，将是很大的开销。把MAXDOP设小，能同时减少WORKER的使用量。所以，如果我们看到等待类型为CXPACKET的话，那么我们可以设置MAXDOP，减少并行度。

比较大的SPID。如果我们看到SPID的号码非常大，如超过1000, 那么通常表明，我们系统有很严重的BLOCKING。SQL SERVER不对连接数做限制，但是对于WORKER数，是有限制的。缺省情况下，最大个数如下：

Number of CPUs	32bit	64 bit
<=4 processors	256	512
8 processors	288	576
16 processors	352	704
32 processors	480	960

对于很大的SPID编号，通常表明，我们的WORKER数是很高的。这种情况比较危险，如果一个新的连接进来，可能没有空闲WORKER来处理这个连接。在CLUSTER环境下，ISALIVE检查会失败，会导致SQL SERVER做FAILOVER。

NON-YIELDING SCHEDULER错误。我们有时候会看到SQL Server会报一个17883错误， NON-YIELDING SCHEDULER。这个错误指的是，在一个SCHEDULER上，会有多个WORKER，它们以友好的方式，互相占用一会儿SCHEDULER资源。某个WORKER占用SCHEDULER后，执行一段时间，会做YIELD，也就是退让，把SCHEDULER资源让出来，让其他WORKER去使用。如果某一个WORKER出于某种原因，不退让SCHEDULER资源，导致其他WORKER没有机会运行，这种现象叫NON-YIELDING SCHEDULER。出现这种情况，SQL SERVER有自动检测机制，会打一个DUMP出来。我们需要进一步分析DUMP为什么该WORKER不会YIELD。

WORKER 用完。我们可以做一个小实验。我们在一台32位机器上，创建上面提及的测试数据库，并且，开启一个同样的未关闭transaction的update语句。

然后执行下面的程序。下面的程序会开启256个连接到SQL Server, 这256个连接由于前面的transaction未闭合，都处于BLOCKING状态。

using System;
using System.Diagnostics;
namespace WORKER
{
    class Program
    {
        static void Main(string[] args)
        {
            for(int i=0; i<256; i++)
            {
                OpenConnection();
            }
        }
        static void OpenConnection()
        {
            ProcessStartInfo startInfo = new ProcessStartInfo();
            startInfo.FileName = "sqlcmd.exe";
            startInfo.Arguments = " -E -S SERVERNAME -d TEST -q \" SELECT * FROM TEST \"";
            Process.Start(startInfo);
        }
    }

}

查询SELECT * FROM sys.dm_os_tasks这时候我们发现有278个TASK，而查询sys.dm_os_schedulers 我们发现有两个CPU, 因此有两个用户SCHEDULER, 每个SCHEDULER上，有128个workers. 加起来有256个WORKERS。针对两个CPU的架构，我们缺省最大的WORKER数是256。所以已经到了极限了。

这时候，我们新开启一个连接，会发现SQL Server连不上，并报如下错误:

这是因为WORKER用完的缘故。新的连接无法获得一个WORKER来做login process。所以导致连接失败。在群集环境下，如果连接不上SQL Server, ISALIVE检查会失败，会引起SQL Server FAILOVER。所有的连接都会被强迫中止，并且SQL Server会在新结点上重新启动。针对这种情况，我们可以修改提高MAX WORKER THREAD，但是并不能最终解决问题，由于BLOCKING缘故，新的连接会迅速积累，一直把MAX WORKER THREAD用完，所以这时候，我们应该检查BLOCKING。使得task能及时完成，释放WORKER。

【总结】

SQL Server的任务调度使得SQL SERVER能够以最快方式处理用户发过来的请求。了解SQL SERVER的任务调度过程，对于我们调整系统性能是非常有帮助的。如适当增加MAX WORKER THREAD，调整MAXDOP，去除BLOCKING等等，了解这些概念，会使得我们的调整更有目的性。

原文：http://blogs.msdn.com/b/apgcdsd/archive/2011/11/24/sql-server-sqlos.aspx

本文链接

关于Blocked Process Report 一个让人迷惑的问题分析

2011-11-25T06:55:00Z

首先看下面这段代码，可以看出：
blocked-process是被阻塞的进程，执行的sql是select * from temp1
blocking-process是正在产生阻塞的进程，执行的sql是select * from temp1 with(nolock)
如果你偶尔抓到了这样的report，肯定会奇怪吧，为什么呢？理论下面的sql不会对上面的sql产生阻塞。

<blocked-process-report>
  <blocked-process>
    <process id="process3d92550" taskpriority="0" logused="0" waitresource="RID: 2:1:218:0" waittime="16975" ownerId="3047491" transactionname="SELECT" lasttranstarted="2011-11-25T14:24:52.210" XDES="0x78ae138" lockMode="S" schedulerid="4" kpid="4676" status="suspended" spid="69" sbid="0" ecid="0" priority="0" trancount="0" lastbatchstarted="2011-11-25T14:24:52.210" lastbatchcompleted="2011-11-25T14:12:08.507" clientapp="Microsoft SQL Server Management Studio - 查询" hostname="R192249" hostpid="9808" loginname="my\name" isolationlevel="read committed (2)" xactid="3047491" currentdb="2" lockTimeout="4294967295" clientoption1="671090784" clientoption2="390200">
      <executionStack>
        <frame line="1" sqlhandle="0x0200000088baad31046d031f04c8e7293882ce42521d893f"/>
      </executionStack>
      <inputbuf>
select * from temp1   </inputbuf>
    </process>
  </blocked-process>
  <blocking-process>
    <process status="sleeping" spid="68" sbid="0" ecid="0" priority="0" trancount="1" lastbatchstarted="2011-11-25T14:25:00.617" lastbatchcompleted="2011-11-25T14:25:00.617" clientapp="Microsoft SQL Server Management Studio - 查询" hostname="R192249" hostpid="9808" loginname="my\name" isolationlevel="read committed (2)" xactid="3047423" currentdb="2" lockTimeout="4294967295" clientoption1="671090784" clientoption2="390200">
      <executionStack />
      <inputbuf>

select * from temp1 with(nolock)   </inputbuf>
    </process>
  </blocking-process>
</blocked-process-report>

下面将重现这个阻塞：
1.首先要设置blocked process shreshold为5秒，这样就可以trace到它：

sp_configure 'show advanced options',1 ; 
GO 
RECONFIGURE; 
GO 
sp_configure 'blocked process threshold',5 ; 
GO 
RECONFIGURE; 
GO

2.创建一个trace，来抓取block:

-- Create a Queue
declare @rc int
declare @TraceID int
declare @maxfilesize bigint
set @maxfilesize = 50 
exec @rc = sp_trace_create @TraceID output, 2, N'D:\Tmp\1', @maxfilesize, NULL 
if (@rc != 0) goto error
-- Client side File and Table cannot be scripted
-- Set the events
declare @on bit
set @on = 1
exec sp_trace_setevent @TraceID, 137, 15, @on
exec sp_trace_setevent @TraceID, 137, 1, @on
exec sp_trace_setevent @TraceID, 137, 13, @on

-- Set the Filters
declare @intfilter int
declare @bigintfilter bigint
-- Set the trace status to start
exec sp_trace_setstatus @TraceID, 1
-- display trace id for future references
select TraceID=@TraceID
goto finish
error: 
select ErrorCode=@rc
finish: 
go

3.创建测试表并插入数据：

use tempdb
create table temp1
(rowid int)
insert into temp1 values (1)
go

4.新建两个会话查询，在会话一中执行：

begin tran
update temp1
set rowid = rowid + 1
--select * from temp1 with(nolock)
--rollback

5.在会话二中执行：

select * from temp1

6.然后再去会话一中执行

select * from temp1 with(nolock)

7.此时会发现，会话二中的sql一直处在等待状态，稍等十几秒后，去会话一执行rollback，这样会话二方可查询出结果。

8.然后执行下面的sql，查看blocked process report:

select cast(TextData as xml), SPID, EndTime, Duration/1000/1000
from fn_trace_gettable(N'D:\Tmp\1.trc', default)
where eventclass = 137

此时就会出现本文最上面的blocked process report，让人误以为是select * from temp1 with(nolock)阻塞了select * from temp1.

9.删除测试数据并停止trace：

drop table temp1
--stop the trace
exec sp_trace_setstatus 2, 0
--delete the trace but leaves the file on the drive
exec sp_trace_setstatus 2, 2

10.总结这个问题，是由于处于同一个事务内的两个sql分两次执行，造成了blocked process report只记录最后一个sql，这样就会另人产生误解，找到不问题所在，应该是需要注意的一个地方。

本文代码参考：http://www.sqlservercentral.com/articles/Blocking/64474/

本文链接

[荐]SAN Performance Tuning with SQLIO

2011-11-22T08:45:00Z

原文：http://sqlserverpedia.com/wiki/SAN_Performance_Tuning_with_SQLIO

Downloading and Configuring SQLIO

[Download SQLIO from Microsoft]

Notice that I said SQLIO, not SQLIOSIM. Experienced database administrators will often direct you to SQLIOSIM because it's easier to use and mimics SQL Server's disk activity patterns. Here's the catch: it won't necessarily test your SAN to its maximum potential. Your SAN team may indicate that if your SQLIOSIM results aren't fast enough, it's a SQL-related problem, not a SAN-related problem. They may use testing utilities from vendors that mimic results closer to what SQLIO will give you. We want to push the SAN's pedal to the metal and find out how fast it'll go in any situation.

After installing SQLIO, edit the param.txt file and change these two parameters:

First parameter - the physical location of the testing file. Change the drive letter to point to the SAN drive you want to test, like T:\testfile.dat.
Last parameter - the size of the testing file in megabytes. Increase this to 20480 or larger. Ideally, you want it to be larger than your SAN's cache, because your real databases will be larger than the SAN's cache.

After saving param.txt, run this at the command line in the same directory where SQLIO is installed in order to create the test file:

sqlio -kW -s10 -fsequential -o8 -b8 -LS -Fparam.txt timeout /T 10

When it finishes, your test file is created, and it's time to run our real tests.

Testing Your SAN Performance

Instead of picking and choosing individual parameters to use, I like to take the shotgun approach: try every possible combination of random versus sequential, low and high numbers of threads, read versus write, etc. The below batch file will take all of the possibilities and run 'em all. Copy/paste this into a text file called SANTest.bat:

sqlio -kW -t2 -s120 -dM -o1 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t2 -s120 -dM -o2 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t2 -s120 -dM -o4 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t2 -s120 -dM -o8 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t2 -s120 -dM -o16 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t2 -s120 -dM -o32 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t2 -s120 -dM -o64 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t2 -s120 -dM -o128 -frandom -b64 -BH -LS Testfile.dat

sqlio -kW -t4 -s120 -dM -o1 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t4 -s120 -dM -o2 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t4 -s120 -dM -o4 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t4 -s120 -dM -o8 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t4 -s120 -dM -o16 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t4 -s120 -dM -o32 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t4 -s120 -dM -o64 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t4 -s120 -dM -o128 -frandom -b64 -BH -LS Testfile.dat

sqlio -kW -t8 -s120 -dM -o1 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t8 -s120 -dM -o2 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t8 -s120 -dM -o4 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t8 -s120 -dM -o8 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t8 -s120 -dM -o16 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t8 -s120 -dM -o32 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t8 -s120 -dM -o64 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t8 -s120 -dM -o128 -frandom -b64 -BH -LS Testfile.dat

sqlio -kW -t16 -s120 -dM -o1 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t16 -s120 -dM -o2 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t16 -s120 -dM -o4 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t16 -s120 -dM -o8 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t16 -s120 -dM -o16 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t16 -s120 -dM -o32 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t16 -s120 -dM -o64 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t16 -s120 -dM -o128 -frandom -b64 -BH -LS Testfile.dat

sqlio -kW -t32 -s120 -dM -o1 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t32 -s120 -dM -o2 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t32 -s120 -dM -o4 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t32 -s120 -dM -o8 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t32 -s120 -dM -o16 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t32 -s120 -dM -o32 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t32 -s120 -dM -o64 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t32 -s120 -dM -o128 -frandom -b64 -BH -LS Testfile.dat

sqlio -kW -t64 -s120 -dM -o1 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t64 -s120 -dM -o2 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t64 -s120 -dM -o4 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t64 -s120 -dM -o8 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t64 -s120 -dM -o16 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t64 -s120 -dM -o32 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t64 -s120 -dM -o64 -frandom -b64 -BH -LS Testfile.dat
sqlio -kW -t64 -s120 -dM -o128 -frandom -b64 -BH -LS Testfile.dat

sqlio -kR -t2 -s120 -dM -o1 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t2 -s120 -dM -o2 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t2 -s120 -dM -o4 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t2 -s120 -dM -o8 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t2 -s120 -dM -o16 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t2 -s120 -dM -o32 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t2 -s120 -dM -o64 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t2 -s120 -dM -o128 -frandom -b64 -BH -LS Testfile.dat

sqlio -kR -t4 -s120 -dM -o1 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t4 -s120 -dM -o2 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t4 -s120 -dM -o4 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t4 -s120 -dM -o8 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t4 -s120 -dM -o16 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t4 -s120 -dM -o32 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t4 -s120 -dM -o64 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t4 -s120 -dM -o128 -frandom -b64 -BH -LS Testfile.dat

sqlio -kR -t8 -s120 -dM -o1 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t8 -s120 -dM -o2 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t8 -s120 -dM -o4 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t8 -s120 -dM -o8 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t8 -s120 -dM -o16 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t8 -s120 -dM -o32 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t8 -s120 -dM -o64 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t8 -s120 -dM -o128 -frandom -b64 -BH -LS Testfile.dat

sqlio -kR -t16 -s120 -dM -o1 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t16 -s120 -dM -o2 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t16 -s120 -dM -o4 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t16 -s120 -dM -o8 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t16 -s120 -dM -o16 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t16 -s120 -dM -o32 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t16 -s120 -dM -o64 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t16 -s120 -dM -o128 -frandom -b64 -BH -LS Testfile.dat

sqlio -kR -t32 -s120 -dM -o1 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t32 -s120 -dM -o2 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t32 -s120 -dM -o4 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t32 -s120 -dM -o8 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t32 -s120 -dM -o16 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t32 -s120 -dM -o32 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t32 -s120 -dM -o64 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t32 -s120 -dM -o128 -frandom -b64 -BH -LS Testfile.dat

sqlio -kR -t64 -s120 -dM -o1 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t64 -s120 -dM -o2 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t64 -s120 -dM -o4 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t64 -s120 -dM -o8 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t64 -s120 -dM -o16 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t64 -s120 -dM -o32 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t64 -s120 -dM -o64 -frandom -b64 -BH -LS Testfile.dat
sqlio -kR -t64 -s120 -dM -o128 -frandom -b64 -BH -LS Testfile.dat

sqlio -kW -t2 -s120 -dM -o1 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t2 -s120 -dM -o2 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t2 -s120 -dM -o4 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t2 -s120 -dM -o8 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t2 -s120 -dM -o16 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t2 -s120 -dM -o32 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t2 -s120 -dM -o64 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t2 -s120 -dM -o128 -fsequential -b64 -BH -LS Testfile.dat

sqlio -kW -t4 -s120 -dM -o1 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t4 -s120 -dM -o2 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t4 -s120 -dM -o4 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t4 -s120 -dM -o8 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t4 -s120 -dM -o16 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t4 -s120 -dM -o32 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t4 -s120 -dM -o64 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t4 -s120 -dM -o128 -fsequential -b64 -BH -LS Testfile.dat

sqlio -kW -t8 -s120 -dM -o1 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t8 -s120 -dM -o2 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t8 -s120 -dM -o4 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t8 -s120 -dM -o8 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t8 -s120 -dM -o16 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t8 -s120 -dM -o32 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t8 -s120 -dM -o64 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t8 -s120 -dM -o128 -fsequential -b64 -BH -LS Testfile.dat

sqlio -kW -t16 -s120 -dM -o1 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t16 -s120 -dM -o2 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t16 -s120 -dM -o4 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t16 -s120 -dM -o8 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t16 -s120 -dM -o16 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t16 -s120 -dM -o32 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t16 -s120 -dM -o64 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t16 -s120 -dM -o128 -fsequential -b64 -BH -LS Testfile.dat

sqlio -kW -t32 -s120 -dM -o1 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t32 -s120 -dM -o2 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t32 -s120 -dM -o4 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t32 -s120 -dM -o8 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t32 -s120 -dM -o16 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t32 -s120 -dM -o32 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t32 -s120 -dM -o64 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t32 -s120 -dM -o128 -fsequential -b64 -BH -LS Testfile.dat

sqlio -kW -t64 -s120 -dM -o1 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t64 -s120 -dM -o2 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t64 -s120 -dM -o4 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t64 -s120 -dM -o8 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t64 -s120 -dM -o16 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t64 -s120 -dM -o32 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t64 -s120 -dM -o64 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kW -t64 -s120 -dM -o128 -fsequential -b64 -BH -LS Testfile.dat

sqlio -kR -t2 -s120 -dM -o1 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t2 -s120 -dM -o2 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t2 -s120 -dM -o4 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t2 -s120 -dM -o8 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t2 -s120 -dM -o16 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t2 -s120 -dM -o32 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t2 -s120 -dM -o64 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t2 -s120 -dM -o128 -fsequential -b64 -BH -LS Testfile.dat

sqlio -kR -t4 -s120 -dM -o1 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t4 -s120 -dM -o2 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t4 -s120 -dM -o4 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t4 -s120 -dM -o8 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t4 -s120 -dM -o16 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t4 -s120 -dM -o32 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t4 -s120 -dM -o64 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t4 -s120 -dM -o128 -fsequential -b64 -BH -LS Testfile.dat

sqlio -kR -t8 -s120 -dM -o1 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t8 -s120 -dM -o2 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t8 -s120 -dM -o4 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t8 -s120 -dM -o8 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t8 -s120 -dM -o16 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t8 -s120 -dM -o32 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t8 -s120 -dM -o64 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t8 -s120 -dM -o128 -fsequential -b64 -BH -LS Testfile.dat

sqlio -kR -t16 -s120 -dM -o1 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t16 -s120 -dM -o2 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t16 -s120 -dM -o4 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t16 -s120 -dM -o8 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t16 -s120 -dM -o16 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t16 -s120 -dM -o32 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t16 -s120 -dM -o64 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t16 -s120 -dM -o128 -fsequential -b64 -BH -LS Testfile.dat

sqlio -kR -t32 -s120 -dM -o1 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t32 -s120 -dM -o2 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t32 -s120 -dM -o4 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t32 -s120 -dM -o8 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t32 -s120 -dM -o16 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t32 -s120 -dM -o32 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t32 -s120 -dM -o64 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t32 -s120 -dM -o128 -fsequential -b64 -BH -LS Testfile.dat

sqlio -kR -t64 -s120 -dM -o1 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t64 -s120 -dM -o2 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t64 -s120 -dM -o4 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t64 -s120 -dM -o8 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t64 -s120 -dM -o16 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t64 -s120 -dM -o32 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t64 -s120 -dM -o64 -fsequential -b64 -BH -LS Testfile.dat
sqlio -kR -t64 -s120 -dM -o128 -fsequential -b64 -BH -LS Testfile.dat

Whew! And that's just one pass - if you want to do multiple passes of the same tests for consistency's sake, like to eliminate the chance that other servers are running on the same SAN and affecting your performance results, you would want to paste that same set of 200+ lines multiple times into your batch file.

Let's take the first line of the batch file and analyze what it's doing:

sqlio -kW -t2 -s120 -dM -o1 -frandom -b64 -BH -LS Testfile.dat

The most important parameters are:

-kW means writes (as opposed to reads)
-t2 means two threads
-s120 means test for 120 seconds
-dM means drive letter M
-o1 means one outstanding request (not piling up requests)
-frandom means random access (as opposed to sequential)
-b64 means 64kb IOs

Do a find & replace in your text file and replace -dM with the drive letter of your choice. If you're testing on your S drive, for example, you would replace -dM with -dS.

Then go to the command prompt in the same directory as SQLIO is installed and type:

SANTEST.BAT > RESULTS.TXT

This will run our newly created batch file and dump the results into a text file. This will take a long time, like six hours or more, and it will be hammering your SAN. Don't run this on a production server, and don't even run it on the same SAN as a production server when the production server is under load because it may time out. I've had instances where this batch file has actually caused a SAN to restart itself, so use this with caution - preferably in a test lab or before your SAN goes live.

Hours later, when it finishes, you'll have a RESULTS.TXT file with lots of juicy metrics about your storage performance.

Importing SQLIO Results into SQL Server

Those text file results are cryptic - time to bring them into our favorite data analysis platform, Microsoft Access. Wait, I'm kidding, put the axe down - we'll import them into SQL Server.

Script to Create the Tables and and ETL Stored Procedure

Before we start, create a database that you'll use for SQLIO data storage or designate an existing utility database that you'll use. This script requires SQL Server 2005 or newer, since it uses the varchar(max) field.

In that database, run the below script to create the tables for results storage:

SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [dbo].[SQLIO_Import](
    [RowID] [int] IDENTITY(1,1) NOT NULL,
    [ParameterRowID] [int] NULL,
    [ResultText] [varchar](max) NULL,
 CONSTRAINT [PK_SQLIO_Import] PRIMARY KEY CLUSTERED 
(
    [RowID] ASC
))
GO
CREATE TABLE [dbo].[SQLIO_TestPass](
    [TestPassID] [int] IDENTITY(1,1) NOT NULL,
    [ServerName] [nvarchar](50) NOT NULL,
    [DriveQty] [int] NOT NULL,
    [DriveRPM] [int] NOT NULL,
    [DriveRaidLevel] [nvarchar](10) NOT NULL,
    [TestDate] [datetime] NOT NULL,
    [SANmodel] [nvarchar](50) NOT NULL,
    [SANfirmware] [nvarchar](50) NULL,
    [PartitionOffset] [int] NULL,
    [Filesystem] [nvarchar](50) NULL,
    [FSClusterSizeBytes] [int] NULL,
    [SQLIO_Version] [nvarchar](20) NULL,
    [Threads] [int] NULL,
    [ReadOrWrite] [nchar](1) NULL,
    [DurationSeconds] [int] NULL,
    [SectorSizeKB] [int] NULL,
    [IOpattern] [nvarchar](50) NULL,
    [IOsOutstanding] [int] NULL,
    [Buffering] [nvarchar](50) NULL,
    [FileSizeMB] [int] NULL,
    [IOs_Sec] [decimal](18, 0) NULL,
    [MBs_Sec] [decimal](18, 0) NULL,
    [LatencyMS_Min] [int] NULL,
    [LatencyMS_Avg] [int] NULL,
    [LatencyMS_Max] [int] NULL,
 CONSTRAINT [PK_SQLIO_TestPass] PRIMARY KEY CLUSTERED 
(
    [TestPassID] ASC
))
GO

CREATE PROCEDURE [dbo].[USP_Import_SQLIO_TestPass]
                @ServerName         NVARCHAR(50),
                @DriveQty           INT,
                @DriveRPM           INT,
                @DriveRaidLevel     NVARCHAR(10),
                @TestDate           DATETIME,
                @SANmodel           NVARCHAR(50),
                @SANfirmware        NVARCHAR(50),
                @PartitionOffset    INT,
                @Filesystem         NVARCHAR(50),
                @FSClusterSizeBytes INT
AS
  SET nocount off
  
  IF @TestDate IS NULL
    SET @TestDate = Getdate()

  /* Add a blank record to the end so the last test result is captured */
  INSERT INTO dbo.SQLIO_Import
    (ParameterRowID, 
     ResultText)
  VALUES
    (0,
     '');
                               
  /* Update the ParameterRowID field for easier querying */
  UPDATE dbo.sqlio_import
  SET    parameterrowid = (SELECT   TOP 1 rowid
                           FROM     dbo.sqlio_import parm
                           WHERE    parm.resulttext LIKE '%\%'
                                    AND parm.rowid <= upd.rowid
                           ORDER BY rowid DESC)
  FROM   dbo.sqlio_import upd
         
  /* Add new SQLIO_TestPass records from SQLIO_Import */
  INSERT INTO dbo.sqlio_testpass
             (servername,
              driveqty,
              driverpm,
              driveraidlevel,
              testdate,
              sanmodel,
              sanfirmware,
              partitionoffset,
              filesystem,
              fsclustersizebytes,
              sqlio_version,
              threads,
              readorwrite,
              durationseconds,
              sectorsizekb,
              iopattern,
              iosoutstanding,
              buffering,
              filesizemb,
              ios_sec,
              mbs_sec,
              latencyms_min,
              latencyms_avg,
              latencyms_max)
  SELECT   @ServerName,
           @DriveQty,
           @DriveRPM,
           @DriveRaidLevel,
           @TestDate,
           @SANmodel,
           @SANfirmware,
           @PartitionOffset,
           @Filesystem,
           @FSClusterSizeBytes,
           (SELECT REPLACE(resulttext,'sqlio ','')
            FROM   dbo.sqlio_import impsqlio_version
            WHERE  imp.rowid + 1 = impsqlio_version.rowid) AS sqlio_version,
           (SELECT LEFT(resulttext,(Charindex(' threads',resulttext)))
            FROM   dbo.sqlio_import impthreads
            WHERE  imp.rowid + 3 = impthreads.rowid) AS threads,
           (SELECT Upper(Substring(resulttext,(Charindex('threads ',resulttext)) + 8,
                                   1))
            FROM   dbo.sqlio_import impreadorwrite
            WHERE  imp.rowid + 3 = impreadorwrite.rowid) AS readorwrite,
           (SELECT Substring(resulttext,(Charindex(' for',resulttext)) + 4,
                             (Charindex(' secs ',resulttext)) - (Charindex(' for',resulttext)) - 4)
            FROM   dbo.sqlio_import impdurationseconds
            WHERE  imp.rowid + 3 = impdurationseconds.rowid) AS durationseconds,
           (SELECT Substring(resulttext,7,(Charindex('KB',resulttext)) - 7)
            FROM   dbo.sqlio_import impsectorsizekb
            WHERE  imp.rowid + 4 = impsectorsizekb.rowid) AS sectorsizekb,
           (SELECT Substring(resulttext,(Charindex('KB ',resulttext)) + 3,
                             (Charindex(' IOs',resulttext)) - (Charindex('KB ',resulttext)) - 3)
            FROM   dbo.sqlio_import impiopattern
            WHERE  imp.rowid + 4 = impiopattern.rowid) AS iopattern,
           (SELECT Substring(resulttext,(Charindex('with ',resulttext)) + 5,
                             (Charindex(' outstanding',resulttext)) - (Charindex('with ',resulttext)) - 5)
            FROM   dbo.sqlio_import impiosoutstanding
            WHERE  imp.rowid + 5 = impiosoutstanding.rowid) AS iosoutstanding,
           (SELECT REPLACE(CAST(resulttext AS NVARCHAR(50)),'buffering set to ',
                           '')
            FROM   dbo.sqlio_import impbuffering
            WHERE  imp.rowid + 6 = impbuffering.rowid) AS buffering,
           (SELECT Substring(resulttext,(Charindex('size: ',resulttext)) + 6,
                             (Charindex(' for ',resulttext)) - (Charindex('size: ',resulttext)) - 9)
            FROM   dbo.sqlio_import impfilesizemb
            WHERE  imp.rowid + 7 = impfilesizemb.rowid) AS filesizemb,
           (SELECT RIGHT(resulttext,(Len(resulttext) - 10))
            FROM   dbo.sqlio_import impios_sec
            WHERE  imp.rowid + 11 = impios_sec.rowid) AS ios_sec,
           (SELECT RIGHT(resulttext,(Len(resulttext) - 10))
            FROM   dbo.sqlio_import impmbs_sec
            WHERE  imp.rowid + 12 = impmbs_sec.rowid) AS mbs_sec,
           (SELECT RIGHT(resulttext,(Len(resulttext) - 17))
            FROM   dbo.sqlio_import implatencyms_min
            WHERE  imp.rowid + 14 = implatencyms_min.rowid) AS latencyms_min,
           (SELECT RIGHT(resulttext,(Len(resulttext) - 17))
            FROM   dbo.sqlio_import implatencyms_avg
            WHERE  imp.rowid + 15 = implatencyms_avg.rowid) AS latencyms_avg,
           (SELECT RIGHT(resulttext,(Len(resulttext) - 17))
            FROM   dbo.sqlio_import implatencyms_max
            WHERE  imp.rowid + 16 = implatencyms_max.rowid) AS latencyms_max
  FROM     dbo.sqlio_import imp
           INNER JOIN dbo.sqlio_import impfulltest
             ON imp.rowid + 20 = impfulltest.rowid
                AND impfulltest.resulttext = ''
  WHERE    imp.rowid = imp.parameterrowid
           /*AND (SELECT Substring(resulttext,(Charindex('size: ',resulttext)) + 6,
                                 (Charindex(' for ',resulttext)) - (Charindex('size: ',resulttext)) - 9)
                FROM   dbo.sqlio_import impfilesizemb
                WHERE  imp.rowid + 7 = impfilesizemb.rowid) > 0 */
  ORDER BY imp.parameterrowid
           
  /* Empty out the ETL table */
  DELETE dbo.sqlio_import
         
  SET nocount off
GO

The script creates three things:

A table called SQLIO_Import where our results will first be dumped from the text file before they're processed
A table called SQLIO_TestPass where our results will be permanently stored in a report-friendly format
A stored procedure called USP_Import_SQLIO_TestPass. The stored procedure takes the data from our imported text file, parses it, and inserts records into the SQLIO_TestPass table.

The stored procedure expects these parameters, which it uses when inserting into SQLIO_TestPass. None of these have to be formatted a specific way - as long as they fit the SQL Server field definitions, they're fine:

@ServerName NVARCHAR(50) - the name of the server you're using for testing. This is mostly useful for servers with locally attached storage as opposed to SAN storage.
@DriveQty INT - the number of drives in the array you're testing.
@DriveRPM INT - you might be testing 10k and 15k variations of the same setup. I suggest lumping drives into categories - don't try to differentiate between drives that report 10,080 RPM or other odd numbers - just stick with 5400, 10000, 150000, etc. For SSD, I prefer to use a number for the generation of SSD, like 1 or 2.
@DriveRaidLevel NVARCHAR(10) - raid 5, raid 0, raid 10, raid DP, etc. (Yes, there are vendor-specific RAID implementations that use letters instead of numbers.)
@TestDate DATETIME - the date you're running the tests. I include this as a parameter because sometimes I've run the same tests on a quarterly basis and I want to track whether things are changing over time.
@SANmodel NVARCHAR(50) - the type of SAN, such as an IBM DS4800 or EMC CX300.
@SANfirmware NVARCHAR(50) - the version of firmware, which can impact SAN performance.
@PartitionOffset INT - Windows systems can use DISKPART to offset their partitions.
@Filesystem NVARCHAR(50) - usually NTFS. Can be used to track testing different filesystems.
@FSClusterSizeBytes INT - the file system cluster size.

Now that our framework is in place, let's import our first round of results.

Importing the Text File into SQL Server 2005

In SQL Server Management Studio, right-click on the database where you want to store the SQLIO performance data and click Tasks, Import Data.
For Data Source, choose "Flat File Source". Browse to your results.txt file, and set the Format to Delimited, Text Qualifier to None, Header row delimiter to {CR}{LF}, and Header Rows to Skip to 0.
Click on the Advanced tab on the left, and there should only be one column, Column 0. Set the DataType to text stream. Click Next.
Your database server and storage database should be shown. Click Next.
For the Destination Table, choose SQLIO_Import and click Edit Mappings. Set the Column 0 destination to be ResultText. Click OK, and click Next.
Click Next until the wizard finishes and imports the data, and then close the wizard.

Open a new query and verify that the data was successfully imported by typing:

SELECT * FROM dbo.SQLIO_Import

If there's no rows, something went wrong with the import process. Stop here and troubleshoot. Otherwise, execute the stored procedure to move the data into the reporting table, like this:

EXECUTE [dbo].[USP_Import_SQLIO_TestPass] 
   'MyServerName'
  ,10
  ,15000
  ,'RAID 10'
  ,'2008/5/6'
  ,'IBM DS4800'
  ,'6.62'
  ,1024
  ,'NTFS'
  ,'64000'

The data will be parsed and inserted into the reporting table, which we can query:

SELECT * FROM dbo.SQLIO_TestPass

Now, the data is arranged in a way that's easier for reporting.

Analyzing the SQLIO Results

Start by analyzing the data to find the fastest SAN throughput:

SELECT * FROM dbo.SQLIO_TestPass ORDER BY MBs_Sec DESC

That column is the SAN's throughput. Notice the LatencyMS_Avg column, though, which indicates the milliseconds of latency. A high throughput number is not necessarily good if the system is taking a long time to respond. Look for five or so of the highest throughput numbers that represents a good balance of high throughput and low latency.

Then, look at the parameters that were used in order to achieve that throughput. Make a note of these, because if you need to do repeated throughput testing on your SAN to test different configurations, you can use these high-throughput configurations to run a much shorter testing pass. Instead of testing your SAN overnight, you can get a quick idea in a matter of minutes because you'll know what parameters tend to drive very high throughput on your SAN. You'll still want to test all parameters when possible, because changes to the SAN may affect how it handles other parameters, but this will give you a quick estimate of whether things are getting better or worse.

More Reading About SQLIO

Here's a few interesting links about other bloggers' experience with SQLIO:

Linchi Shea's Blog on SQL Server Storage - Linchi Shea does in-depth storage testing with different SANs and settings in order to wring the most performance out, and he explains his testing methodologies.
Solid State Drives and SQL - Chad Boyd tests a few drive configurations.
Storage Area Networks 101 Video - podcast on SQLServerPedia explaining the basics of SAN technology for database administrators.
Microsoft whitepaper on Disk Subsystem Performance for Windows - explains different raid methods, drive types, etc and how they impact performance
Resolving hangs and errors when using SQLIO - especially on Windows Server 2008 R2 or Windows 7.

以下是我测试的Raid5 6块和9块的部分结果载图：

本文链接

[转]How to find who is using / eating up the Virtual Address Space on your SQL Server

2011-11-15T08:07:00Z

Well, this is often a tricky situation, where you are running into Virtual Address Fragmentation and getting OOM (out-of-memory) errors in your SQL Server. More often than not there is confusion between physical memory pressure vs. virtual memory pressure. Adding more RAM is definitely not a solution here!

Here are some sample error messages you might have seen in your SQL Errorlog which will indicate if this is physical memory or virtual memory issue:

SQL 2000
WARNING: Failed to reserve contiguous memory of Size= 65536.
SQL Server could not spawn process_loginread thread.

SQL 2005/2008
Failed Virtual Allocate Bytes: FAIL_VIRTUAL_RESERVE 122880

Error: 701, Severity: 17, State: 123.
There is insufficient system memory to run this query.

As the errors above indicate, the problem is in reserving a fixed size in the virtual address space of SQL Server. Note: the size indicated above in Bytes. E.g. 65536/1024 = 64 KB

Typical symptoms you would notice in these situations are:-

1) Database or Log Backups might start failing
2) You are unable to make a new connections to SQL.
3) Certain jobs which require memory from non-BPool region will fail.

Many a time, these problems go away automatically without any action taken. This indicates an intermittent problem when at a certain point in time; there was virtual memory pressure which resulted in above messages being printed to the SQL Errorlog.

Dealing with VAS fragmentation or running out of VAS on SQL server 2000 was rather painful and required setting up additional debugging techniques to get down to the bottom of the issue. You might have used some of the following tools:-

1) VMSTAT
2) Debugging Tools for Windows (to capture a manual dump of sqlservr.exe)
3) T2551 to generate a filtered dump in SQL Server when running into a OOM condition.
4) TLIST.exe to identify modules loaded in SQL Server.

Luckily, starting with SQL 2005 there is an in-memory DMV which tracks the virtual address space (VAS) of your SQL Server process. Here are some queries which will help you find out how much virtual address is available on sqlservr.exe which is FREE and how much is total available (Free+InUse)

1. Will tell you the size of the biggest contiguous block in VAS

SELECT convert(varchar,getdate(),120) as [Timestamp], max(region_size_in_bytes)/1024 [Total max contiguous block size in KB]

from sys.dm_os_virtual_address_dump where region_state = 0x00010000 --- MEM_FREE

2. Will also tell us size of largest contiguous block plus the region marked as MEM_RESERVE (this is your non-BPool area reserved during SQL Startup, sometimes referred to as MTL - MemToLeave)

With VASummary(Size,Reserved,Free) AS

(SELECT

Size = VaDump.Size,

Reserved = SUM(CASE(CONVERT(INT, VaDump.Base)^0)

WHEN 0 THEN 0 ELSE 1 END),

Free = SUM(CASE(CONVERT(INT, VaDump.Base)^0)

WHEN 0 THEN 1 ELSE 0 END)

FROM

(

SELECT CONVERT(VARBINARY, SUM(region_size_in_bytes))

AS Size, region_allocation_base_address AS Base

FROM sys.dm_os_virtual_address_dump

WHERE region_allocation_base_address <> 0x0

GROUP BY region_allocation_base_address

UNION

SELECT CONVERT(VARBINARY, region_size_in_bytes), region_allocation_base_address

FROM sys.dm_os_virtual_address_dump

WHERE region_allocation_base_address = 0x0

)

AS VaDump

GROUP BY Size)

SELECT SUM(CONVERT(BIGINT,Size)*Free)/1024 AS [Total avail Mem, KB] ,CAST(MAX(Size) AS BIGINT)/1024 AS [Max free size, KB]

FROM VASummary

WHERE Free <> 0

3. The below query will identify the memory reserved by non-BPool components in SQL Server

select SUM(virtual_memory_reserved_kb)/1024 as virtual_memory_reserved_mb from

sys.dm_os_memory_clerks

where type not like '%bufferpool%'

4. To identify if any of the space used is by SQL Server procedure cache itself, you can use this query

SELECT SUM(PAGESUSED)*8/1024 'MB of MemToLeave memory consumed by procedures'

FROM MASTER.DBO.SYSCACHEOBJECTS WHERE PAGESUSED >1

DBCC MEMORYSTATUS also has good information on whether the usage from the non-BPool region is coming from SQL or non-SQL components. If it is SQL 2000, check the value of “OS Committed” and it is SQL 2005/2008 look at the value of “MultiPage Allocator” for each memory clerk. Just to re-state my assumption in case you are not sure

1 SQL Server Page = 8 KB –> SinglePage Allocator
> 1 Page or > 8KB –> MultiPage Allocator

Apart from these you need to pay special attention to the following components are all of the below do not use memory from the Buffer Pool region but make direct VirtualAlloc() calls to reserve memory and then commit them,

1) Any OLE/COM components loaded in SQL Server
2) Extended Stored Procedures (use sys.dm_os_loaded_modules to identify the module loaded in sqlserver process space).
3) SQL Mail components
4) Any XML prepared documents using sp_xml_preparedocument
5) Linked Server Providers
6) Large Plans stored in Procedure Cache
7) Very frequent Backups also may cause MTL area depletion. (Please investigate using the parameters MAXTRANSFERSIZE and BUFFERCOUNT, if this is the case).
8) SQL CLR (recommended to be used on 64-bit SQL Servers)

Above list is certainly not exhaustive, but is more enough to get started in looking at the right areas. While we are on this topic, it is important to understand the difference between a Reserve and a Commit. These are windows concepts are remain the same for SQL Server as well, after all its VirtualAlloc() underneath the covers.

MEM_COMMIT – Region in VAS this is backed by RAM/paging file
MEM_RESERVE – Region in VAS with no actual physical storage either in RAM or in the paging file.

The problems we talked about so far occur when a call to VirtualAlloc() with MEM_RESERVE is made and that “reservation” fails resulting in the errors printed to errorlog. Most times, the call to reserve is subsequently followed by a COMMIT, but its not mandatory. I can reserve now and commit later on using the base address of the reservation. SQL Server is smart enough and during starting reserves a certain region of the address space referred to as MTL or Non-BPool region. It is here the crunch is and it is here the issue needs to be investigated/fixed.

A quick workaround for above issues is to add the startup parameter –gXXX. (Sample usage- -g512)
XXX- is the amount in MBytes to reserve on startup.

I would advise against doing this as this is a workaround where you are increasing the MTL region rather than find out who/what is consuming it. Slava’s blog is a good read also on this topic.

Sudarshan Narasimhan
Technical Lead, Microsoft SQL Server CSS

原文：http://blogs.msdn.com/b/sqlserverfaq/archive/2010/02/16/how-to-find- who-is-using-eating-up-the-virtual-address-space-on-your-sql-server.aspx

本文链接

[转]Troubleshooting MSDTC issues with the DTCPing tool

2011-11-03T07:29:00Z

http://blogs.msdn.com/b/distributedservices/archive/2008/11/12/troubleshooting-msdtc-issues-with-the-dtcping-tool.aspx

Every day the Distributed Services support team in Microsoft helps customers in troubleshooting some of the most common Distributed Transaction errors which are a direct result of MSRPC (Microsoft Remote Procedure Call) communication failing in a network because of some Security\Firewall settings. On an application layer (like SQL), these are the common error messages that will be bubbled up.

Server: Msg 7391, Level 16, State 1, Line 2 The operation could not be performed because the OLE DB provider 'SQLOLEDB' was unable to begin a distributed transaction. OLE/DB provider returned message: New transaction cannot enlist in the specified transaction coordinator.
New transaction cannot enlist in the specified transaction coordinator (0x8004d00a)
The transaction has already been implicitly or explicitly committed or aborted (0x8004d00e)

If you encounter one of the above error messages while using Distributed Transactions from your application, feel free to use the DTCPING tool to find out where the problem lies. This blog explains how to use the DTCPing tool to narrow down the source of the problem and how to fix it.

Distributed Transactions (specifically OleTx transactions) use the MSRPC protocol to talk to MSDTC on the other machine. To make sure that the two machines are able to communicate with each other using the MSRPC protocol, you can run the DTCPING tool on both the machines to test whether the normal RPC communication is working fine or not. Before talking about the various errors that are thrown by this tool, it is very important to understand the right way to run the tool properly so that we can get the right output from the tool

Distributed Transactions come in to picture whenever there is more than one server participating in a transaction. If there is just a single server involved in the distributed transaction and you are still getting some errors while running distributed transactions, then this is not the right article to focus upon. Once you have determined the right servers that are participating in the distributed transaction, launch the DTCPING.EXE tool simultaneously on both of the machines. DTCPING.EXE should be running at the same time on both the machines before you put the right server name and click the PING button.
In the Remote Server Name section of the DTCPING tool you should only put the NETBIOS name of the server with which you are trying to run distributed transaction. Any test which is done after specifying the IP address of the server or the FQDN of the server is an invalid test. You MUST provide the NETBIOS name of the server against which you are trying to run distributed transactions as MSDTC uses MSRPC as the underlying mechanism and MSRPC works on NETBIOS name resolution only.
In a Cluster - On a clustered machine you should always put the name of the NETWORK RESOURCE on which the MSDTC resource is dependent on in the Remote Server Name field. To find out the right NETWORK NAME to use in DTCPing, open up the Cluster Administrator and go to the group in which the MSDTC Resource is present. That group should have one network name resource on which the DTC Resource is dependent on. To find out the network name, just go to the properties of the network name resource and go to the Parameters tab. The name that you see there is what is network name for this MSDTC resource. Lets understand this with an example :- lets say that you have a 2 node cluster with two nodes with the NETBIOS names as DBSERVER01 and DBSERVER02 and you are trying to run distributed transactions from a third server APPSERVER. Then to run DTCPing in the right way, you should start the DTCPING.EXE on the APPSERVER and the active node of the cluster. (By active node, I mean the node on which the DTC resource is online). Then from the Cluster Administrator go to the properties of the NETWORK NAME resource in which the Distributed Transaction Coordinator resource is present and go to the PARAMETERS tab. Note this network name. Once you have determined the right network name, launch DTCPING on the active node of the cluster and the APPSERVER and inside the DTCPing window on the APPSERVER, put in the network name of the clustered MSDTC Resource inside the (Remote Server Name) field and then click PING.
You should always have only one instance of DTCPING.EXE running on the server when you are testing and for subsequent tests you should always close the DTCPING tool and open it again.

After ensuring that you have read the above points properly, you should just run the DTCPING tool and in the Remote Server name type in the right server name and click PING. If everything works fine you should see the following message being returned by the tool. (Here DTCPing was ran from machine with NETBIOS name SOURCE to the machine with NETBIOS name DESTINATION)

++++++++++++++++++++++++++++++++++++++++++++++
DTCping 1.9 Report for SOURCE
++++++++++++++++++++++++++++++++++++++++++++++
RPC server is ready
++++++++++++Validating Remote Computer Name++++++++++++
11-21, 04:31:01.455-->Start DTC connection test
Name Resolution:
DESTINATION-->65.52.22.254-->DESTINATION.contoso.com
11-21, 04:31:01.470-->Start RPC test (SOURCE-->DESTINATION)
RPC test is successful
Partner's CID:084B708C-F0C5-4E65-95F2-8E2DEF73FFF3
++++++++++++RPC test completed+++++++++++++++
++++++++++++Start DTC Binding Test +++++++++++++
Trying Bind to DESTINATION
11-21, 04:31:01.830-->SOURCE Initiating DTC Binding Test....
Test Guid:B5544E05-D64B-40AC-B283-71947914DED3
Received reverse bind call from DESTINATION
Network Name: SOURCE
Source Port: 1116
Hosting Machine:SOURCE
Binding success: SOURCE-->DESTINATION
++++++++++++DTC Binding Test END+++++++++++++

If you see the above message, go to the second server and put the name of the source server in the Remote Server Name field and hit PING and make sure that you see the same results as above. If both of the servers return success after running the DTCPING tool but the distributed transactions are still not working, then you should see the PART II of this article which talks about how to fix distributed transaction issues when the DTCPING works fine between two machines.

If the result of the tool is not success, figure out what error you are getting and follow the steps mentioned in the sections below to fix the error message.

ERROR MESSAGE 1 - gethostbyname failure

DTCPing log file: C:\Documents and Settings\username\Desktop\DTC_PING\TURTLES8618
RPC server is ready
Please Start Partner DTCPing before pinging
++++++++++++Validating Remote Computer Name++++++++++++
Please refer to following log file for details: C:\Documents and Settings\username\Desktop\DTC_PING\TURTLES861840.log
Error(0xB7) at nameping.cpp @43
-->gethostbyname failure -->183(Cannot create a file when that file already exists.)
Can not resolve abc Invalid remote host name:abc

I think this error is more than self explanatory. You will get this if the host name that you added in the Remote Server Name is not a valid host name. Make sure that the remote server name that you specified in the DTCPING tool resolves to a valid IP address by running the ping command. If that host name is not resolving to any IP address, you can try adding the host name in the hosts file and try running the tool again.

ERROR MESSAGE 2 - The RPC server is unavailable

DTCping log file: C:\Documents and Settings\username\Desktop\DTC_PING\TURTLES8618
RPC server is ready Please Start Partner DTCping before pinging
++++++++++++Validating Remote Computer Name++++++++++++
Please refer to following log file for details: C:\Documents and Settings\username\Desktop\DTC_PING\TURTLES861896.log
Invoking RPC method on turtle86
Problem:fail to invoke remote RPC method Error(0x6BA) at dtcping.cpp @303
-->RPC pinging exception -->1722(The RPC server is unavailable.)
RPC test failed

This indicates that either the port 135 or one of the ports in the DCOM port range is blocked on the firewall. To confirm this further let's say you ran DTCPING from SERVER01 to SERVER02 and you got this error. Now open up a command prompt on SERVER01 and type telnet SERVER02 135 (Before running this test just ensure that the Telnet service is started on the server. On a Windows 2008 Server, the telnet service is not installed by default and you have to install it by configuring the role services on the server.). If you see a blank window with a cursor blinking, that is enough to tell that the port is NOT blocked but if the telnet command fails with an error, you can easily infer that the port 135 is blocked and you should check with your network team to get the port 135 opened up bi-directionally on the firewall. If telnet to port 135 works just fine, then do a NETSTAT -anob on the SERVER02 and find out the port on which the DTCPING.EXE is listening. Then come back to SERVER01 and do a telnet SERVER02 <PORT_NUMBER>. If you got this error, then this test has to fail. MSDTC uses the MSRPC protocol to talk to MSDTC on the remote machine. As a result of the normal working of the MSRPC protocol, MSDTC is free to use one of the dynamic ports within the range 1024-65535. Well if MSDTC can use any one port within this range, then how should I be configuring my firewall? Should I got ahead and open up the entire range on my firewall? Then what is use of a firewall? The answer to that is - you don't have to open up this entire range on the firewall but you can restrict the RPC End Point Mapper Service to just specify a range of ports that will be used by any DCOM program. Please note again - this range impacts ALL the programs that use MSRPC and not just MSDTC. You can configure this range in the registry or in the DCOMCNFG UI. To specify this range, scroll down below to the section "RESTRICTING THE DCOM PORT RANGE" which talks about how to restrict DCOM to use a specific port range.

ERROR MESSAGE 3 - The remote procedure call failed

RPC server is ready
++++++++++++Validating Remote Computer Name++++++++++++
Problem:fail to invoke remote RPC method
Error(0x6BE) at dtcping.cpp @303
-->RPC pinging exception -->1726(The remote procedure call failed.)
RPC test failed

This error is a result of a firewall disconnecting the TCP connection between the two machines. You have to get in touch with your firewall administrators to help you figure out why the Firewall is closing the TCP connection between two machines. To troubleshoot this error you can install Network Monitor tool on both the machines and re-run the test and you should see a TCP RESET packet sent by a network device which is trying to close the connection.

ERROR MESSAGE 4 - There are no more endpoints from the endpoint mapper

DTCping log file: C:\Documents and Settings\username\Desktop\DTC_PING\TURTLES8626
RPC server is ready Please Start Partner DTCping before pinging
++++++++++++Validating Remote Computer Name++++++++++++
Please refer to following log file for details: C:\Documents and Settings\username\Desktop\DTC_PING\TURTLES86268.log
Invoking RPC method on turtle86
Problem:fail to invoke remote RPC method Error(0x6D9) at dtcping.cpp @303
-->RPC pinging exception -->1753(There are no more endpoints available from the endpoint mapper.)
RPC test failed

This error makes it appear that RPC is running out of DCOM Ports but you should not infer this error as a port exhaustion immediately. If you are able to run DTCPING.EXE on both the machines and during startup of the EXE, the tool doesn't complain of an out of port error, then this error is just a result of Firewall blocking the ports and the troubleshooting for this error should be exactly same as troubleshooting the "The RPC server is unavailable" error which is described above. Why am I saying that? Let's say that we are running out of DCOM ports (which can typically happen if you have specified a port range and the range is too small, something less than 30), then you should see an error the moment you start the DTCPING.EXE. Because that's when the DTCPing.exe will contact the End Point Mapper service (RpcSS) and ask for a dynamic port. If the DTCPing.exe starts up just fine, then it means that it got the right port allocated to it and hence there is no question of the Endpoint Mapper running out of DCOM ports.

ERROR MESSAGE 5 - ERROR MESSAGE 5 - Access is Denied

Invoking RPC method on TURTLE86
Problem:fail to invoke remote RPC method
Error(0x5) at dtcping.cpp @303
-->RPC pinging exception
-->5(Access is denied.)

This error will only occur if the destination machine is a Windows XP machine or a Windows VISTA machine. This is an additional security in the RPC layer which is configured on the client operating systems. More details on this security aspect is described in the article "RPC Interface Restriction" on Technet

RPC Interface Restriction http://technet.microsoft.com/en-us/library/cc781010.aspx

To get rid of this error just follow these steps to configure the registry key and REBOOT the machine.

1. Click Start, click Run, type Regedit, and then click OK.
2. Locate and then click the following registry key:
HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows NT
3. On the Edit menu, point to New, and then click Key.
Note If the RPC registry key already exists, go to step 5.
4. Type RPC, and then press ENTER.
5. Click RPC.
6. On the Edit menu, point to New, and then click DWORD Value.
7. Type RestrictRemoteClients, and then press ENTER.
8. Click RestrictRemoteClients.
9. On the Edit menu, click Modify.
10. In the Value data box, type 0, and then click OK.
Note To enable the RestrictRemoteClients setting, type1.
11. Close Registry Editor and restart the computer.

ERROR MESSAGE 6 - Not enough resources are available to complete this operation

DTCping log file: Z:\Tools\DTC_PING\TURTLE865072.log
Error(0x6B9) at rpcUtil.cpp @133
-->I_RpcServerAllocateIpPort
-->1721(Not enough resources are available to complete this operation.)
Error(0x6B9) at rpcUtil.cpp @54
-->1721(Not enough resources are available to complete this operation.)

You will get this error message immediately after starting the DTCPING window. This error message means that RPC is running out of the ports on the machine because the DCOM Port range that you defined is too less or there are a lot of other RPC applications which are using DCOM ports (Typically a DCOM or a RPC program just uses one DCOM port but it is possible for an application to acquire more than one DCOM port by calling the RPC API's directly). To fix this error message increase the port range by following these steps.

RESTRICTING THE DCOM PORT RANGE

1. Go to Start -> Run. Type in DCOMCNFG.
2. Go to the properties of the My Computer node under the Computers folder underneath Component Services.
3. Under the My Computer Properties look under the Default Protocols tab.
4. Over there make sure that Connection-oriented TCP/IP is selected and then click on Properties.
5. You will see a window like this

If you don’t see a range above and the window looks exactly like the one above, that would mean that the DCOM port range is not configured on the machine.
You can click Add in the above window and type the range (let's say as 5000-5100) and say Ok. Make sure it looks like this. (Both the radio buttons should be selected for Internet Range)

You have to configure this range on both the machines and after that you have to reboot both the servers for this Range to take effect. After doing that you have to open up the same range on your firewall bi-directionally.

Let's say you have already opened enough ports but still you get this error message. In this case you should run NETSTAT -anob on the machine which is returning this error message and try to find out which program is using all the ports. You should look for the ports that you have defined in the RPC Port range and look for all EXE's which are listening on that port range.

We hope this article gives you enough insight on how to troubleshoot issues with MSDTC using the DTCPing tool and we hope that going further you should be able to troubleshoot and diagnose issues related to MSDTC on your own. If you still need assistance from us to solve any DTCPING errors that were talked about in the above blog, please feel free to collect the DTCPING log files from both the machine (where DTCPING was ran) and open up a Support Incident with Microsoft. We (the MSDTC support team) will be more than happy to provide you a timely resolution to the problem once we have the right data to look at.

If you are interestedly to dig deeper in to the DCOM and the Firewall concepts, feel free to explore the following articles which talks about DCOM issues in general.

DTCPING.exe download http://download.microsoft.com/download/d/0/0/d00c8f6b-135d-4441-a97b-9de16a1935c1/dtcping.exe
Using Distributed COM with Firewalls http://msdn.microsoft.com/en-us/library/ms809327.aspx
Configuring Microsoft Distributed Transaction Coordinator (DTC) to work through a firewall http://support.microsoft.com/kb/250367/en-us
Description of names and IP addresses that an MSDTC client in a cluster environment must have http://support.microsoft.com/kb/311846/en-us
Troubleshooting Problems with MSDTC http://msdn.microsoft.com/en-us/library/aa561924.aspx

本文链接

某个订阅库下存在很多关于更新MSreplication_subscriptions表造成的大量死锁

2011-11-03T01:22:00Z

订阅库中有很多的死锁现象，MSreplication_subscriptions表中有8条记录，死锁大概是1小时40个，如下所示：

deadlock-list
deadlock victim=processdbf1c8
process-list
   process id=processdbf1c8 taskpriority=0 logused=2116 waitresource=PAGE: 6:1:3304140 waittime=577 ownerId=1250752686 transactionname=user_transaction lasttranstarted=2011-11-03T09:17:09.920 XDES=0xffffffffaadb39a8 lockMode=U schedulerid=2 kpid=2868 status=suspended spid=72 sbid=0 ecid=0 priority=0 trancount=2 lastbatchstarted=2011-11-03T09:17:15.100 lastbatchcompleted=2011-11-03T09:17:15.100 clientapp=EEAAPRD\EEAAPRD_db_ee_occ to RDJ hostname=EEAADIST hostpid=4932 loginname=repl_user isolationlevel=read committed (2) xactid=1250752686 currentdb=6 lockTimeout=4294967295 clientoption1=671156320 clientoption2=128056
    executionStack
     frame procname=adhoc line=1 stmtstart=164 sqlhandle=0x02000000246863336efb6f4b519564562cfd41f094d18561
update MSreplication_subscriptions set transaction_timestamp = cast(@P1 as binary(15)) + cast(substring(transaction_timestamp, 16, 1) as binary(1)), "time" = @P2 where UPPER(publisher) = UPPER(@P3) and publisher_db = @P4 and publication = @P5 and subscription_type = 0 and (substring(transaction_timestamp, 16, 1) = 0 or datalength(transaction_timestamp) < 16)
     frame procname=unknown line=1 sqlhandle=0x000000000000000000000000000000000000000000000000
unknown
    inputbuf
(@P1 varbinary(14),@P2 datetime,@P3 nvarchar(13),@P4 nvarchar(7),@P5 nvarchar(14))update MSreplication_subscriptions set transaction_timestamp = cast(@P1 as binary(15)) + cast(substring(transaction_timestamp, 16, 1) as binary(1)), "time" = @P2 where UPPER(publisher) = UPPER(@P3) and publisher_db = @P4 and publication = @P5 and subscription_type = 0 and (substring(transaction_timestamp, 16, 1) = 0 or datalength(transaction_timestamp) < 16)
   process id=process407b8e8 taskpriority=0 logused=37032 waitresource=PAGE: 6:1:3304141 waittime=577 ownerId=1250752084 transactionname=user_transaction lasttranstarted=2011-11-03T09:17:08.693 XDES=0xffffffff99c24958 lockMode=U schedulerid=8 kpid=4356 status=suspended spid=92 sbid=0 ecid=0 priority=0 trancount=2 lastbatchstarted=2011-11-03T09:17:14.917 lastbatchcompleted=2011-11-03T09:17:14.913 clientapp=EEAAPRD\EEAAPRD_db_ee_occ_lucene to RD hostname=EEAADIST hostpid=7184 loginname=repl_user isolationlevel=read committed (2) xactid=1250752084 currentdb=6 lockTimeout=4294967295 clientoption1=671156320 clientoption2=128056
    executionStack
     frame procname=adhoc line=1 stmtstart=164 sqlhandle=0x02000000c535342ae6f47e336782ad406ac4eccd72796c0c
update MSreplication_subscriptions set transaction_timestamp = cast(@P1 as binary(15)) + cast(substring(transaction_timestamp, 16, 1) as binary(1)), "time" = @P2 where UPPER(publisher) = UPPER(@P3) and publisher_db = @P4 and publication = @P5 and subscription_type = 0 and (substring(transaction_timestamp, 16, 1) = 0 or datalength(transaction_timestamp) < 16)
     frame procname=unknown line=1 sqlhandle=0x000000000000000000000000000000000000000000000000
unknown
    inputbuf
(@P1 varbinary(14),@P2 datetime,@P3 nvarchar(13),@P4 nvarchar(7),@P5 nvarchar(20))update MSreplication_subscriptions set transaction_timestamp = cast(@P1 as binary(15)) + cast(substring(transaction_timestamp, 16, 1) as binary(1)), "time" = @P2 where UPPER(publisher) = UPPER(@P3) and publisher_db = @P4 and publication = @P5 and subscription_type = 0 and (substring(transaction_timestamp, 16, 1) = 0 or datalength(transaction_timestamp) < 16)
resource-list
   pagelock fileid=1 pageid=3304140 dbid=6 objectname=db.dbo.MSreplication_subscriptions id=lock2f350b80 mode=IU associatedObjectId=72057594038845440
    owner-list
     owner id=process407b8e8 mode=IU
    waiter-list
     waiter id=processdbf1c8 mode=U requestType=wait
   pagelock fileid=1 pageid=3304141 dbid=6 objectname=db.dbo.MSreplication_subscriptions id=lock3184e900 mode=IU associatedObjectId=72057594038845440
    owner-list
     owner id=processdbf1c8 mode=IU
    waiter-list
     waiter id=process407b8e8 mode=U requestType=wait

发现已经有人把这个提交给微软了：

http://connect.microsoft.com/SQLServer/feedback/details/695689/transactional-push-replication-deadlock-on-msreplication-subscriptions#tabs

解决方法：

重建了该表的聚集索引，目前一小时内未出现死锁，持续监控中。
alter index uc1MSReplication_subscriptions on dbo.MSreplication_subscriptions REBUILD

本文链接

[转]Working Set和Private Bytes

2011-10-27T08:38:00Z

原文http://www.cnblogs.com/awpatp/archive/2010/01/26/1656651.html

Task Manager跟Performance Monitor的区别(Working set和Private bytes)

windows server 2003 :

在Performance monitor中可以通过private bytes和Virtual bytes来衡量程序的内存使用. 在task manager中, 也有Memory Usage和VM Size两项. 但是仔细比较后会发现Memory Usage并不是对应private bytes, VM Size也不是对应Virtual Bytes.

其实, task manager中的Memory Usage对应的是working set, VM Size对应的是private bytes. 因此如果使用task manager观察内存使用, 应该注意到这个差别.

Working Set和Private Bytes

==============

一个有趣的问题是, working set指目前程序所消耗的物理内存, private bytes指的是commit的内存, 那么为什么有些进程的working set比private bytes还大? 要回答这个问题, 需要仔细看看两者的定义:

"Working Set refers to the numbers of pages of virtual memory committed to a given process, both shared and private."
"Private Bytes is the current size, in bytes, of memory that this process has allocated that cannot be shared with other processes."

所以, Working Set包含了可能被其他程序共享的内存, 而Private Bytes只包括被当前进程使用的内存.

DLL是一个典型的可能被其他程序共享的资源. DLL的加载使用文件映像, 因此包含DLL的物理内存可以被同时映像到多个进程上. 所以在进程中加载DLL的内存只能算到working set上, 而不能被算到private bytes上.

在解决内存问题的时候Shared的部分一般可以不用考虑.

一个进程使用内存的时候, 它占用的内存会被分为两部分, 一部分是working set, 另一部分是private byte减去working set. 其中working set是贮存在物理内存中的, 而剩下的另一部分是paging file, 存在磁盘上.

一般来说把所有进程的working set加起来会比你机器上所拥有的物理内存要大, 这是因为有Shared的资源(比如DLL)的缘故.

TechNet上的定义

==============

Working Set

The set of memory pages (areas of memory allocated to a process) recently used by the threads in a process. If available memory on the server is above a specified threshold, pages remain in the Working Set of a process even if they are not in use. When available memory falls below a specified threshold, pages are removed from the Working Set. If these pages are needed, they will be returned back to the Working Set before they leave main memory and are made available for other processes to use.

Private Bytes

Displays the current number of bytes this process has allocated that cannot be shared with other processes.

Virtual Bytes.

The current size, in bytes, of the virtual address space for this process. The virtual address space limit of a user mode process is 2 GB, unless 3 GB address space is enabled by using the /3GB switch in boot.ini.

Working Set, Virtual Bytes, 和Private Byte的更多信息

==============

原文:

Private Bytes refer to the amount of physical memory (RAM) that the process executable has asked for - not necessarily the amount it is actually using. Private bytes are "private" because they (usually) exclude memory-mapped files (i.e. shared DLLs). But - here's the catch - they don't necessarily exclude memory allocated by those files. So if your executable depends on any libraries - and almost every executable does - you cannot always tell whether a change in private bytes was due to the executable itself or some library it links to. Also note that "physical memory" is not a perfect description - what it really means is bytes that can be addressed without a page fault.

翻译:

Private Bytes指的是进程可执行程序已经索要了的物理内存的量, 不一定是它实际正在使用的内存量. Private Bytes之所以是"private"的, 是因为它通常不包括内存映射文件(memory-mapped file), 比如说共享的DLL. 但是, 有一点要注意, 虽然private bytes不包括共享的DLL本身, 但是会包括由那些共享的DLL所分配的内存. 所以, 如果你的可执行文件依赖于任何的dll库(其实几乎所有的可执行程序都要依赖于dll库), 你就不能明确private byte的一个变动是由可执行程序自己引发的, 还是由DLL分配的. 还有, 注意, "物理内存"其实并不是对private bytes的一个完美的描述, 物理内存的真实的意义是: 无需page fault就可以寻址到的内存.

原文:

Working Set refers to the total physical address space used by the process. This includes memory-mapped files and quite possibly several other things; a 32-bit process can access 4 GB of address space and not all of that address space is actually memory. This is the same value that gets reported in Task Manager's "Mem Usage" and has been the source of endless amounts of confusion in recent years. Similarly to private bytes, this is "physical" in the sense that it can be addressed without a page fault.

翻译:

working set的意思是被进程使用的全部物理内存地址空间. 这包括内存映射文件, 还有些其他的东西. 一个32位的进程可以寻址4GB的地址空间, 而且这4G并不都在实际的内存中. 跟private bytes相似, working set描述中的physical的意思也是无需page fault即可寻址.

原文:

Virtual Bytes are the total virtual address space occupied by the entire process, including memory-mapped files such as shared DLLs. This is like the working set except it includes data that has already been paged out and is sitting in a pagefile somewhere. The total virtual bytes used by every process on a system under heavy load will add up to significantly more memory than the machine actually has.

翻译:

Virtual Byte是整个进程占用的全部虚拟地址空间, 包括诸如共享dll在内的内存映射文件. 它跟working set很像, 不一样的是, 它还得算上已经被page out的存放在别的什么地方的pagefile中的数据. 一个高负荷系统中所有进程的全部的virtual bytes加起来, 会比机器实际拥有的内存多很多.

本文链接