CN101278259A

CN101278259A - 执行确定性处理的***和方法

Info

Publication number: CN101278259A
Application number: CNA2006800365837A
Authority: CN
Inventors: P·梅德斯; C·海尔; B·E·布兰查
Original assignee: Asterion Inc
Current assignee: Asterion Inc
Priority date: 2005-09-02
Filing date: 2006-08-29
Publication date: 2008-10-01
Also published as: US9189239B2; EP1922611A2; US20070055846A1; WO2007027595A2; US8074059B2; WO2007027595A3; US20120159131A1; TW200720968A; US8719556B2; JP2009507299A; KR20080100330A; US20150012733A1

Abstract

此***和方法用来在一个非确定性计算机***上执行确定性操作。在一个实例中，***强迫一个或多个计算机指令在一个恒定的执行时间内执行。确定性引擎，如果必要，等待一个可变长度的时间，以确定计算机指令的在恒定的执行时间内执行。因为执行时间恒定，操作是确定性的，因此可以用于要求确定性行为的应用中。例如，这样的确定性引擎可以用于自动测试(ATE)应用中。

Description

执行确定性处理的***和方法

技术领域

本发明是关于处理，特别是非确定性计算机***中的处理。

背景技术

自动测试***(ATE)成功的关键是可重复性。可重复的测试***意味着，在两个相同的设备上执行一个预先确定的测试序列，得到相同的结果。因此，如果对每个待测设备提供相同的激励，测试结果可以作为评估设备质量的一个可信的资源。“相同的”激励，不仅意味着任何相关测试条件(电压，电流，温度等等)的值相同，还意味着条件应用的相关时间相同。

今天，ATE领域的大多数测试设备包含一个或者多个计算机***。实现测试步骤的计算机***必须按确定性的方法产生这些测试步骤，以保证整体的确定性。这样的计算机面临的一个问题是成本——设计一个完整的适用于测试的计算***(比如，能够产生一致的结果的***)不仅需要昂贵的硬件设计和维护，而且也需要昂贵的软件设计，包括操作***，用户界面，驱动，工具等等。因此，适用于ATE的计算机***对于大多数公司来说，购买和维护费用都无法承受。

一种降低这种***成本的方法，是采用组装计算机部件和***。然而，由于上述对确定性的要求，组装通用计算机***通常不适合这种应用。如果通用计算机***可以应用于ATE。ATE的拥有和操作成本就可以降低。

发明内容

本发明的一个实施方案，提供了一种执行确定性处理的***。此***包括用于执行一个或多个指令的处理实体，和用于调节一个或多个指令的执行时间使之成为一个恒定的值的部件。根据一个实施方案，此部件用于将执行时间调节为一个或多个指令的最大执行时间。根据另一个实施方案，此部件用于调节一个或多个指令的执行时间，使之在一个或多个指令的多个执行中保持相同的恒定值。根据另一个实施方案，这些多个执行发生在不同的计算机***中。根据另一个实施方案，不同的计算机***具有不同的处理能力。根据另一个实施方案，此部件用于使一个或多个指令在一个预先制定的时间段内执行。根据另一个实施方案，部件适于等待一段时间，从而将执行时间调节为恒定值。

根据一个实施方案，本***进一步包括时间参考，其中部件用于利用时间参考确定相关时间。根据另一个实施方案，部件用于基于处理器时钟周期的计数值确定相关时间。根据另一个实施方案，时间参考包括接口，其中部件用于通过接口获得处理器时钟周期的计数值。根据另一个实施方案，部件适于确定执行一个或多个指令的总时间，并且适于等待一段时间，从而将执行时间调节为恒定值。根据另一个实施方案，部件用于根据多个计数值确定消耗的时间。根据另一个实施方案，计数器的值是处理器的时间戳计时器。根据另一个实施方案，处理器是奔腾型处理器。根据另一个实施方案，***是自动测试***的一部分。

根据此发明的一个方面，提出了一种用于执行确定性处理的计算机实现的方法。此方法包括在一个计算机***中执行一个或多个指令的行为，测量执行行为的执行时间，以及等待一段时间将执行时间调节为一个恒定的值。根据一个实施方案，等待一段时间的行为，包括在执行行为之后等待一段时间，直到执行时间的恒定值被消耗完。根据另一个实施方案，此方法进一步包括测量一个或多个指令的执行，以及根据测量确定一个或多个多个指令的最大执行时间。根据另一个实施方案，此方法进一步包括将恒定值设置为最大执行时间的行为。根据另一个实施方案，本方法进一步包括确定一个或多个指令的最大执行时间的动作。根据另一个实施方案，本发明进一步包括将恒定值设置为最大执行时间的行为。

根据另一个实施方案，方法进一步包括在一个或多个指令的多个执行中，将一个或多个指令的执行时间调节为恒定值。根据另一个实施方案，多个执行出现在不同的计算机上，根据另一个实施方案，不同的计算机***具有不同的处理能力。根据另一个实施方案，本方法进一步包括实行在预先制定的时间段内，在一个计算机***中执行一个或多个指令的行为。根据另一个实施方案，本方法进一步包括，等待一段时间，从而将执行时间调节为恒定时间的行为。根据另一个实施方案，本方法进一步包括确定相关时间的行为。

根据一个实施方案，方法进一步包括提供时间参考，以及利用这个时间参考确定相关时间的行为。根据另一个实施方案，本方法进一步包括根据处理器时钟周期的计数器值确定相关时间的行为。根据另一个实施方案，本方法进一步包括确定用来执行一个或多个指令的总时间的行为，以及等待一段时间将执行时间调节为恒定值的行为。根据另一个实施方案，本方法进一步包括根据多个计数器的值确定消耗的时间的行为。根据另一个实施方案，计数器的值是处理器的时间戳计时器。根据另一个实施方案，处理器是奔腾型处理器，根据另一个实施方案，方法通过一个自动测试***执行。

本发明进一步的特性和优点以及各实施方案的结构和操作，将在下面结合附图详细描述。在图中，相同的参考数字表示相同的或者功能相似的元素。此外，参考数字中最左边的一个或两个数字标识此参考数字第一次出现的图

附图说明

附图没有特意的量化。在图中，在各图中每个相同的或者近似相同的部件用相同的数字表示。为了表达清晰，并不是每个部件都会在每一个图中被标注。在附图中：

图1给出了可以执行本发明的各种实施方案的计算机***的实例。

图2给出了根据本发明的一个实施方案的***结构实例

图3是根据本发明的一个实施方案的执行确定性处理的过程。

图4是根据本发明的一个实施方案的确定性引擎实例的框图。

图5是另一个根据本发明的一个实施方案的执行确定性处理的过程。

图6是代码通过非确定性***执行的实例。

图7是根据本发明的一个实施方案，代码通过一个或多个确定性***执行的实例。

图8给出了一个展示本发明实施方案的假想设备的输出和测量。

具体实施方式

本发明不局限于对下文以及图表的描述所提出的结构细节和部件布置的申请。本发明可以是其他实施例，且能够通过各种方法施行或者实现。同时，文中所使用的措辞和术语是为了描述，不应局限地理解。“包含”，“包括”，“具有”，“由……组成”以及文中其他同义词，是为了将后面列出的项目以及等价的项目和附加的项目一起包含进来。

本发明提出了一种用于执行确定性处理的***和方法。根据本发明的一个实施方案，在一个需要确定性结果的***中，使用非确定性计算机***会有益处。例如，在一个ATE***中，使用通用计算机***、处理器、和(或)软件会起到降低保有和维护这一***的成本的作用。举例来说，一个实现ATE***的通用计算机***的成本可能是一个专门设计的***的1/10^th。为了这个目的，这里提出了一种方法，允许这样的非确定性***通过确定性的方法运行。

根据本发明的一个实施方案，测试工程师所使用的确定性***，比如ATE，具有以下几个方面：

(a)有一个松弛点，测试工程师可以将这一点作为参考时间(例如，时间0(to))，后续的测试可以以此作为参考。

(b)有一个确定性的测试调动程序，在预先设定的参照参考时间(to)的相关时间启动测试步骤。

利用传统的***可以很容易地满足条件(a)，执行起来通常很简单。例如，在参考时间t0，设备可能与激励断开，其温度被设置为室温(管理员温度)。同时，在一个测试***中，测试工程师可以将激励设置为“开始测试”(SOT)状态。

而条件(b)比较难满足。例如，用来满足条件(b)的解决方案可能包括一个使用稳定时间参考的串行电路来执行测试步骤。如果将计算机设计为纯串行电路，为这个计算机所写的程序就是一个串行器，通过确定性方式产生测试步骤。然而，这样的计算机通常需要一个特别开发的操作***和相应的应用程序，以确保步骤按确定性方式执行。

根据本发明的一个方面，如果尝试利用组装计算机满足条件(b)，会出现问题。特别是，使用通用计算机***，其硬件和软件设计试图达到最大性能。在执行ATE程序时，通用计算机试图通过任何可能方法，尽快完成所有测试步骤。然而根据本发明的一个方面，条件(b)定义了，在一个预先设定的时间开始一个新的测试步骤，而不是像当前的组装计算机以及他们的相关软件那样尽快完成。

当今的组装计算机利用各种机制实现最大性能，比如高速缓冲存储器，流水线，多执行路径(探测执行)，分支预报以及其他机制。这些机制中的大多数，是根据依赖于处理器的历史或(和)当先状态的训练猜想做出决定。也就是说，根据执行(例如数据已被存取，等等)的历史(或样本)，可以预知下面的任务步骤(例如，某数据被载入高速缓冲存储器，哪些指令在每个流水线级上被解码，某数据被从硬盘上恢复等等)。当然，如果猜测是错的，性能就会变差，任务的运行速度下降。进一步地，这些机制在不同的运行时间通常有不同的操作，因为这些机制依赖于其他程序的性能和(或)计算机操作***的状态。因此，由于***变量数量的原因，今天大多数用来提高计算机性能的技术，会导致计算机***的性能难于预测和(或)复制，其中多数***变量在运行时间被确定。

由于性能难于预测，大多数ATE公司在***设计时忽略上面所讨论的条件(b)(通过增长的设计成本印证此忽略合理)，并且直接将调节测试应用程序直到得到满意的可重复性的问题留给了测试工程师。当然，仔细地定制测试应用程序是一种模拟条件(b)的策略，但是这一策略很麻烦而且得到的应用程序非常脆弱。潜在的计算机硬件或者软件操作参数或者配置的任何改变，都可能影响这一客户定制，因此不允许任何确定性操作。

因此，一种不仅实现完全可重复***，而且实现一个不依赖于潜在的计算机硬件和软件的技术，对确定性应用，例如一个ATE***非常有益。根据本发明的一个方面，如果一个计算机操作的最大执行时间可以预测，这个计算机操作可以被强迫以一种确定性的方法操作。特别是，如果计算机操作可以按照这个最大操作时间执行，那么这个计算机***的执行是可预测的。在一个实施例中，计算机对一个特别的操作的执行可以被延迟，以保证此操作在正确的执行时间执行。

根据本发明的一个方面，一个确定性的引擎被提供给一个通用计算机***。根据一个实施方案，这个确定性引擎可以使得总执行时间对于任何特殊的指令设置都是恒定的。如果期望的总执行时间大于或等于最大执行时间，总执行时间可以设置为一个恒定值。最大执行时间可以通过分析相关指令(从而测量他们的最大执行时间)，或者经验性地通过执行设置于不同的处理器上下文的指令来确定。

由于一个期望的执行时间被设置为恒定值，假设实际的执行时间不超过最大执行时间，此执行在不同的计算机***中是相同的。由于新的处理器有更大的容量和更高的性能，采用这样的确定性引擎的软件应用程序可以直接接入这些新的环境，而不会消除确定性行为。即由于所期望的执行时间在一个特定的计算机***上比最大执行时间要长，任何软件应用程序可以接入一个更强大的，对一种特定的指令设置可能有更短的最大执行时间的计算机***。通过这种方法，软件应用程序在不同的计算机***上执行的时候可以确定性地运行，在应用程序设计上的投资可以在***间被保护。为了将应用程序接入能力较差的或者不稳定的***，需要加以鉴证，以确保设计的最大执行时间不超出。

通用计算机***

本发明的各个实施方案可以在一个或多个计算机***中实现。这些计算机***可以是，例如，通用计算机(比如基于intel奔腾处理器的计算机，Motorala PowerPC，AMD Athlon or Turion，Sun UltraSPARC，Hewlett-Packard PA-RISC处理器，或者任何其他形式的处理器)。根据本发明的各个实施方案，一个或多个任何型号的计算机***都可以用来执行确定性处理。此外，***可能位于一个单个的计算机上，或者可能分布在一组通过通信网络链接的计算机上。

根据本发明的一个实施例，一个通用计算机***被配置以执行所描述的任意确定性功能，包括(但不限于)执行测试程序的测试步骤。***可以执行其他的功能，包括其他需要确定性功能的应用程序，并且本发明不局限于具有任何特定功能或者功能的设置。

图1给出了一个通用计算机和网络***的框图，其上可以实现本发明的各个方面。例如，本发明的各个方面可以以在包括图1给出的通用计算机***101在内的一个或多个计算机***上执行的专门软件的形式实现。计算机***101可能包含一个处理器104，它连接到一个或多个存储设备105，比如硬盘驱动、存储器或者其他用于存储数据的设备。存储器105，通常在计算机***101操作期间用于存储程序和数据。计算机***101的部件可能通过一个互联机制，例如网络110来连接，此互联机制可能包括一个或多个总线(例如，在集成在同一台机器上的部件之间)，和(或)一个网络(例如，在位于分开的离散机器上的部件之间)。互联机制使得通信(例如，数据，指令)可以在***101的***部件之间交互。

计算机***101也可能包括一个或多个输入/输出(I/O)设备106，例如，键盘、鼠标、跟踪球、麦克风、触摸屏、打印设备、显示器、音箱等等。此外，计算机***101可能包括一个或多个接口(例如网络通信设备108)，它们将计算机***101和通信网络(附加或者作为网络110的选项)相连。

存储***109通常包括一个计算机可读写非易失记录媒介，其中信号被存储用来定义一个被处理器执行的程序，或者存储在媒介之上或之内的用来被程序处理的信息。媒介可以是，例如，硬盘或者闪存。通常，在操作中，处理器将数据从非易失记录媒介读到另一个允许通过处理器对信息进行更快的存取的存储器上。这个存储器通常是可变的，随即存取存储器，例如动态随机存取存贮器(DRAM)或者静态存储器(SRAM)。该存储器可以放置在存储***109中，如图所示，或者在内存***105中。处理器104通常在集成电路内存104中处理数据，然后在处理完成之后将数据复制到与存储器109相应的媒介。已知有很多机制用来管理数据在媒介和集成电路内存单元之间的移动，本发明不局限于此。本发明不局限于一个特定的内存***或者存储器***。

计算机***可能包括特殊编程的、特殊用途的硬件，例如，一个专用集成电路(ASIC)。本发明的方面可以在软件、硬件或者固件、或者其结合中实现。此外，这种方法、行为、***、***元件和部件可以以上述计算机***的一部分，或者一个独立的计算机的形式实现。

尽管只通过可以实现本发明的各种方案的一类计算机***的例子展示了计算机***101，但本领域技术人员应该理解的是本发明的各个方面不局限于在图1所示的计算机***中来实现。本发明的各个实施方案可以在如图1所示的有不同结构或部件的计算机上实现。计算机***101可以是可用高级计算机程序语言编程的通用计算机***。计算机***101亦可以通过特殊编程的专用硬件实现。在计算机***101中，处理器104通常是可买到的处理器，比如众所周知的Intel公司提供的奔腾系列处理器。很多其他的处理器也可以利用。这样的处理器通常执行一个操作***，例如微软公司提供的基于Windows的操作***(例如，Windows NT，Windows 2000(Windows ME)，Windows XPc等操作***)。苹果公司提供的MAC OS System X操作***，SunMicrosystems公司提供的Solaris操作***，或者各种来源的可得到的UNIX操作***。很多其他操作***也可用，本发明不局限于任何特殊的操作***。

处理器和操作***共同定义个一个计算机平台，可以用高级程序语言为这个平台编写应用程序。应该理解，此发明不局限于特殊的计算机***平台、处理器、操作***或者网络，除非通过一个或几个权利要求中所限定的那样。并且，对于本技术领域的技术人员应该清楚，本发明不局限于一种特别的程序语言或者计算机***。进一步地，也可以采用其他适当的程序语言和其他适当的计算机***。

计算机***的一个或多个部分可能分布在一个或多个连接到通信网络的计算机***上。这些计算机***也可能是通用计算机***。例如，本发明的各个方面可能分布在一个或多个计算机***(例如，服务器)上，通过配置来为一个或多个用户计算机提供服务，或者作为分布***的部分执行一个全局任务。例如，本发明的各个方面，可以在一个客户端-服务器***或者是多层***上执行，该***包括分布在一个或多个根据本发明的不同实施方案执行不同功能的服务器***中的部件。这些部件可以是在一个通信网络上(例如因特网)利用通信协议(例如TCP/IP)通信的可执行代码、中间代码(例如，IL)、或者是解释性代码(例如，Java)。

人们应该理解的是本发明的执行不局限于任何特殊***或者***组。本发明也不局限于任何具体的分布结构、网络或者通信协议。

本发明的各实施方案可以通过面向对象的编程语言编程，例如SmallTalk，Java，C++，Ada，or C#(C-Sharp)实现。也可以使用其他面向对象的编程语言。此外，也可以使用函数语言、脚本语言、汇编语言、和/或逻辑编程语言。本发明的各个方面可以在非编程环境中实现(例如，在HTML、XML或者其他格式中创建的文档，这些格式在浏览器程序视窗中显示用户界面(GUI)或者执行其他功能)。本发明的各个方面可能以编程的或者非编程的元件实现，或者以上任意的结合。

***的各个方面可以通过***100内的一个或多个***来实现。例如，本***可以是单一或多处理器***。在一个实例中，本***包括在一个***(例如个人电脑)上执行的软件程序。这样的***可以允许用户执行一个或多个要求确定性行为的功能。这样的***可能包括，例如，测试***、控制***、航空工业中应用的***、以及其他。

***结构实例

图2给出了根据本发明的一个实施方案的***实例的结构图。需指出图2仅用于图示的目的，其他结构也可以用于实现本发明的一个或多个方面。

如图2所示，一个计算机***200(例如，一个上文中结合图1所讨论的通用计算机***)可能用于实现一个确定性***。计算机***200可能包括一个确定性引擎程序201，它允许任何应用程序204以确定性方式操作。根据本发明的一个实施方案，***200不必是确定性***，但可以是如上文中结合图1所讨论的通用计算机***。最后，***200可能包括一个操作***202，一个或多个处理器203，以及一个或多个I/O部件206。计算机***200可以选择性地包括实时操作***，和/或实时部件205以帮助应用程序实时操作。这样的实时部件包括，例如，TenAsys公司，Beaverton，OR提供的INTIME实时编程扩展。

根据本发明的一个实施方案，在计算机***上执行操作时，一个确定性引擎为判断提供一个稳定的时间参考。此外，确定性引擎程序可能为其他程序提供指示，并指出何时操作应该执行。

如上所述，可能为一个特殊的操作或者操作设置(例如，计算机指令)确定最大执行时间。最大执行时间可以通过，例如，直接测量操作的执行来确定(例如通过很多执行来确定)，或者可以通过其他所知道的方法确定。如果一个计算机***(例如，计算机***200)的操作的执行不超过最大执行时间，那么计算机***可以被强制按照确定性方式操作。

为了确定实现上述概念的解决方案，考虑一个操作，作为可以重复任意次的，执行时间可以测量的任意计算机处理。提出以下法则：

如果一个操作执行在时间上有上限，那么可以强制操作在一个固定的执行时间执行。

证明：设O代表一个操作。由于操作O是可重复的，T_o(n)可定义为操作O在第n次运行时的执行时间。此定理假定操作O在时间上有上限，那么存在T_max使得下面的等式成立：

T₀{n)≤T_max， (1)

现在假定，根据以下操作的消耗，定义一个操作，它的执行时间由下面的等式定义：

W(n)＝[T_max-T_o(n)]+E (2)

这里，值E是操作消耗执行中的固有误差(比如，开销)。如果计算机***可以每次都按照原始操作执行操作消耗，构成的操作时间就是一个恒定值：

T₀(n)+W(n)＝T_max+E (3)

以上理论可以结合所述设备以一个操作实现。也就是说，可以定义一个操作使得组合执行的时间消耗是恒定值。因此，只要执行时间是恒定的且可预知的，就可以确定性地执行一个非确定性***(例如，通用计算机***)上的操作。

因此，如果一组操作的执行时间限定在一个固定的执行时间段，执行就可以预知从而可重复。图3给出了一个根据本发明的一个实施例的，执行确定性处理的处理实例，其中全部执行时间保持恒定。在方框301中，处理300开始。在方框302中，确定最大执行时间。例如，一个或多个操作的最大执行时间可能通过测量等方法确定。在方框303中，一个或多个操作被执行，所消耗的时间被测量。在方框304中，确定性引擎被延迟至确定的最大执行时间，这样总的操作执行时间是一个恒定值。在方框305中，操作300完成。

如以上讨论的，确定性引擎程序提供一个稳定的时间参考，这样消耗的时间就可以测量。根据一个实施方案，确定性引擎程序可能根据一个执行确定性引擎的处理器或者其他计算机***单元提供的信息确定时间。在一个实施例中，确定性引擎执行一个基于Intel的、已知的奔腾处理器的通用计算机***。例如，CPU指令RDTSC(读取时间戳计时器)通过奔腾系列处理器引入，读取从处理器最后一次重启后经过的时钟周期的数量。时间戳计时器为64bit宽，提供足够的计数数据，超过计算机的寿命(在1.0GHZ，时间戳计时器在大于584年以后才计满)。

如果一个计算机程序(例如，一个确定性引擎)在被分析的数据区域之前或者之后读取时间戳计时器，这两种测量之间的差给出执行相关的代码所消耗的CPU时钟周期总数。剩下的唯一问题是这一时钟周期数如何与时间关联。假设k是用来执行操作O的时钟周期数，下面的等式确定了执行此操作的时间。

T_{o} = \frac{k}{f_{cpu}} - - - (4)

这里，f_cpu是CPU的时钟频率。不幸的是，没有CPU指令可以找回CPU时钟频率，所以需要开发一种方法提供这一值。

测量CPU频率

在一个实施例中，可编程定时器具有已知的固定计数频率1.1931817MHz。如果一个计算机***能够在操作之前和之后读取定时器，就可以确定所执行操作的执行时间。设k_t是计时器记录的用来执行操作O的计数，那么执行这一操作的时间可以通过以下测量：

T_{o} = \frac{k_{t}}{1193181.7} - - - (5)

如果对同一个操作O使用上述两个方法，执行时间T_o完全相同，使得下面的等式成立：

\frac{k}{f_{cpu}} = \frac{k_{t}}{1193181.7} - - - (6)

最终：

f_{cpu} = 1193181.7 \frac{k}{k_{t}} - - - (7)

根据以上的讨论，就可以实现上述等式(2)中的操作消耗实例W(n)：

(a)读取并保存时间戳计时器；

(b)执行操作O；

(c)将等于T_max的时钟周期数与所保存的时间戳计时器相加，此值计作k_end；

(d)读取时间戳计时器；

(e)如果时间戳计时器的值小于k_end返回(d)。

注意：

·等式(2)和(3)中的误差E根据步骤(a)，(c)，(d)和(e)确定；

·执行步骤(d)和(e)需要消耗时间，所以这一循环可能导致误差E变化(循环误差)；

·这里提到的序列(a)到(e)为确定性操作O_D；

·这里提到的(a)和(c)到(e)为用确定性引擎执行的确定性包或函数。

图4给出了根据本发明的一个实施例，用来执行确定性处理的***实例400。更具体地，***400包括可以执行一个或多个上述操作的确定性引擎406。***400包括一个确定性引擎和一个外部实体403。外部实体403可能是采用确定性引擎以确定性方式执行一个或多个操作的硬件和(或)软件部件(例如，一个应用程序)。

确定性***406包括一个时间参考401和一个处理器402。时间参考402执行一个时间保持操作。处理器402可能包括，例如，一个在通用计算机***上执行的软件程序，执行一个或多个确定性引擎406的函数。引擎406可能接受和/或提供指令，来帮助将最大执行时间保持在一个恒定值。最后，处理器可能为外部实体403提供一个或多个指令404。类似地，外部实体403可能为处理器402提供一个或多个指令。

在图4所示的执行实例中，提供时间参考401以保持对经过时间的跟踪。时间参考401也可以提供一个值(直接地或者间接地)与一个距已知事件的时间上的距离相关。这个值随着时间的推移不断地变化。这里这个值也以时间计数的形式表示。

同样，可以用一个数学函数绘制时间单位时间计数的变化图。换言之，给出任意两个时间计数的值之间的差，这个数学函数就可以指出获得这两个时间计数值的时刻之间经过了多少时间。这个数学函数在下文中被称为delta时间函数。

给出一个时间参考和delta时间函数的具体实现，可以得到一个与任意两个连续的时间计数值之间的差相应的最大时间跨度。这个最大时间跨度在下文中被称为时间参考精度。

在一个例子中，时间参考401提供一个到外部实体的接口。这个接口允许处理器从时间参考获得时间计数。当处理器从时间参考请求一个时间计数时，在处理器发出请求和处理器***收到时间计数之间，可能存在一个延迟。这个延迟在这里称作接口延迟。根据一个实施方案，这个接口延迟对于此接口的任何执行都是可预知的。对于此接口的任何具体执行，最小和最大接口延迟之间的差被称作接口抖动。

图5给出了根据本发明的一个实施方案用于执行确定性操作的处理500。通过一个或多个上文结合图4提到的***400的元件，与处理500相关的一个或多个行为将被执行。

在方块501中，处理500开始。在方块502中，产生一个可以被外部实体(例如，实体403)控制的保持/进行信号。更特别地，保持/进行信号可以通过确定性引擎产生。根据一个实施方案，保持/进行信号作为一个对外部实体的指示，用来控制外部实体处理的时间。

在方块503中，确定性引擎从一个外部实体收到一个等待请求。这个等待请求可以指定一个具体的时间长度，在这之后保持/进行信号改变状态。在方块504中，确定性引擎将等待时间段变为时间计数单位。在方块505中，确定性引擎从时间参考获得时间计数值。并在方块506中根据时间计数值确定消耗的时间(例如，时间跨度)。

确定性引擎在方块507中进入等待状态，并保持这一状态直到消耗时间大于或等于等待请求，在这之后保持/进行信号在方块508中设定。在方块509中，处理500结束。

根据本发明的一个具体实施例，处理器可能包括，例如，一个可以执行下列任务的计算机：

1、产生(例如，通过一个确定性引擎406)一个可以通过外部实体(例如外部实体403)控制的保持/进行信号(例如，信号404)。

2、从外部实体收到一个等待请求(例如，信号405)。这个等待请求指定了一个特定时间，在其后保持/进行信号改变状态。

3、将请求的等待时间从时间单位改变为与之相等的时间计数单位。

4、从时间参考获得时间计数值(例如，通过接口)。

5、将时间计数的两个值提供给delta时间函数，确定与这两个时间计数值的差相应的时间跨度。

6、执行确定性循环算法定义如下：

a.收到一个等待请求

b.将请求时间段变成时间计数单位

c.清除保持/进行信号

d.获得一个初始时间计数

e.执行下面的方块直到delta时间结果大于或等于等待请求

{获得一个当前时间计数

将delta时间函数提供给当前初始时间计数

}

设置保持/进行信号。

如果存在一个逆delta时间函数，则可以通过下列流程实现确定性循环算法的的外一种实施方案：

a.接收等待请求

b.把请求的时间段转换为时间计数单位

c.清除保持/进行信号

d.在等待请求上应用逆delta时间函数

e.当逆delta时间结果＞当前时间计数时，循环执行以下代码块

{

获得当前时间计数值

}

设置保持/进行信号

在处理器中执行确定循环算法需要花费一些时间，时间长短决定于处理器对算法的执行速度。在这里，这段时间被看做是确定循环算法的开销。

确定循环算法的开销包括两个部分：初始化开销和循环开销。初始化开销依赖于处理器***的实现，与进入循环前获取新时间计数值的初始化指令相关。循环开销是处理器执行一次循环花费的时间；如果不在处理器内部获取时间，则还需包括获得时间的接口开销。

根据本发明的一个实施方案，对于任何确定循环算法的处理器实现，初始化开销和循环开销(即确定循环算法的开销)都必须是可以预测的。对于任何特定确定循环算法的处理器实现，初始化开销最小值和最大值的差异在这里被称为初始化抖动。与此类似，循环开销的最小值和最大值的差异被称为循环抖动，包括接口抖动。***整体抖动反映了在给定实现中初始化抖动和循环抖动的综合效果。

对于前述***的任何一种实现，可以在等待请求所要求的时间段内改变保持/进行信号的状态，此时间段等于总***抖动，如果等待请求所要求的时间大于或等于时间精度+初始化开销+循环开销+设置保持/进行信号转变时间。

外部***给确定性引擎发送一个等待请求，然后等待发布保持/进行信号。等待请求到达确定性引擎所需要的时间被称为等待请求延迟。根据本发明的一个实施方案，要求等待请求延迟对于确定性引擎用户的任意执行都是可预测的。和上述其他的延迟相似，也有一个和等待请求信号的发出相应的等待请求抖动。如果外部***知道等待请求延迟，它就能通过对等待请求期间花费的时间的数学处理对这个延迟进行补偿。

保持/进行信号到达外部***所需要的时间称为保持/进行信号延迟。根据本发明的一个实施方案，要求保持/进行信号延迟对于确定性引擎的用户的任意执行都是可预知的。和上述其他的延迟相似，也有一个和保持/进行信号相应的保持/进行信号抖动。

外部***用来对保持/进行信号状态的变化进行响应的时间，这里称作***反应时间。根据一个实施方案，要求***反应时间对于确定性引擎(例如外部实体403)的用户的执行是可预知的。与前述其他延时相似，也有一个于***反应时间相应的***反应抖动。

对于一个给定的等待请求，确定性引擎的用户可以达到的精确性等于总***抖动+***反应抖动，如果最小等待请求时间段比时间精度+初始化开销+接口延迟+转变保持/进行信号时间+***反应时间长。

根据各个实施方案，可以找出确定性引擎的一个应用，例如，在软件自动测试设备(ATE)领域，并且可以用于迫使测试函数消耗一个非常精确且可预先定义的时间。现有的自动测试设备软件的确定性精度最好可以达到几十微秒。根据本发明的一个实施方案，一个具有相当小的总***抖动和***反应抖动，以及最小的延迟和开销的确定性引擎可以对ATE软件的确定性行为提供很大的改进。

根据本发明的一个实施方案，上述确定性引擎可以利用Intel公司Santa Clara，CA提供的著名的Intel奔腾IV处理器执行。Intel奔腾系列处理器包括一个具有相当高精度以及很短延迟的嵌入式时间参考，以及它的接口。这个嵌入式时间参考被称作时间戳计时器(TSC)。

TSC是一个累计从计数器初始化开始出现的处理器时钟周期的计时器。奔腾处理器时钟频率可以看作是固定的(在特定情况下)，这意味着时间参考精度恒定，并等于1/处理器频率。例如，一个奔腾IV处理器在3.0GHz频率下运行时，可提供333ps的时间参考精度。

此外，TSC的内容可以通过一个单处理器指令读取(RDTSC)。这意味着接口延时将是这个单一指令的执行时间，在奔腾IV处理器3.0GHz频率下为40ns左右。对于相同的处理器，接口延时抖动为3ns左右。

上述指出的利用奔腾IV处理器的特殊应用，其近似的确定性循环算法开销为356ns，初始化开销为312ns，循环开销为44ns。由于奔腾IV处理器的内部结构，其中普遍采用指令流水线，无法获得一个典型的实际测量的总***抖动值。

根据一个实施方案，确定性引擎执行的操作可能通过一个在通用计算机***上执行的软件程序执行。例如，本发明的各种实施方案可能在一个或多个软件程序中执行。在一个具体例子中，确定性引擎可能被收入一个单独的类，以下称为SMX Timing。下一段描述了这一类的一个实现。应该可以理解的是，下面的方法只是作为例子给出，本发明不局限于任何特殊的方法或者方法的结合。

基本操作

SMX_Timing类可以实现为一个头文件(例如，SMX_Timing.hxx)和一个支撑DLL(例如，实现SMXJTiming.xyz，其中‘xyz’可以是windows编程环境下的‘dll’程序，或者INtime编程环境下的‘rsF’程序)。这个头文件包含了类定义，以及关键时间方法的具体实现(使用inline方式)。DLL文件则可以提供包含类校准程序在内的实用方法。

在加载的时候，SMX_Timing DLL实施类校准并确定CPU的主频。根据一个实施例，校准进程会自动执行，且在CPU时钟变化前不必再次被执行。CPU时钟正常情况下不会改变，除非发生一些特殊事件，例如一种为了降低能耗而降低CPU速度的保护机制。

一旦类校准完成，且CPU主频被确定，一个新的类实例才能被创建，那些实用方法也才可用。由于校准过程非常重要，必需首先确定其确实成功，才能实例化这个类的对象，或者调用DLL中提供的多数实用方法。验证校准过程比较容易，例如，可以调用一个静态的类方法(比如下面提到的Islnitialized方法)。下面会进一步介绍这类方法的使用方式和具体示例。

SMXJ_Timing类方法

根据一个实施方案，出于性能原因，采用汇编语言将类中定义的关键时间方法实现为inline函数。简单起见，下面只描述关键方法。

SMXJ_Timing(void)

根据一个实施方案，从这个计时类创建的对象包含自己的校准因子。计时类的构造函数将全局校准因子复制到对象中，以便在需要时，可以对象为基础进行修改。

SMXJJ64 Start(void)

这个Start方法读取当前的时间戳计数器并将计数器值保存到一个标记属性。这个标记属性可被用做计算已消耗时间(例如，使用一个名为Elapsed的方法)的参考点，或者被用作等待一段既定时间(例如，使用一个名为WaitUntil的方法)的参考点。下面给出的代码实例实现了上述功能：

1. xor eax，eax

2. cpuid ；同步

3. ；

4. rdtsc ；读取CPU计数到edx:eax

5. ；

6. mov ecx，this

7. ；

8. mov[ecx+marker+0]，eax；保存标计

9. mov[ecx+marker+4]，edx

以上列出的代码按如下方式执行：第1行和第2行同步CPU；所有被执行指令在时间戳计时器在第4行采样之前完成；第6行找回当前目标数据区域的指针；第8行和第9行将时间戳保存为标记属性。在退出时，此方法返回一个无符号64-bit值，表示CPU时钟中的时间戳计时器。

SMX_S64 Elapsed(void)

这个Elapsed方法计算当前时间戳和最后一次调用Start方法时的采样之间的差。给出的可选校准因子允许消除任何期望的开销。下面给出的代码实例实现了Elapsed方法的功能：

1. xor eax，eax

2. cpuid ；同步

3. ；

4. rdtsc ；读取计数

5. ；

6. mov ecx，this

7. ；

8. sub eax，[ecx+marker+0]；计算消耗时间

9. sbb edx，[ecx+marker+4]

10. ；

11. sub eax，[ecx+eCF+0] ；应用校准因子

12. sbb edx，[ecx+eCF+4]

上面的代码和Start方法很相似，唯一的区别是第8和第9行，这两行计算了刚采到的时间戳和被保存为标记的时间戳之间的差，以及第11行和第12行将存储在eCF属性的校准因子减去。此方法返回的计算结果为一个有符号的64-bit值(根据校准因子，返回的值可能是负数)。

在类初始化过程中(例如，当载入DLL时或者当调用CalibrateTiming方法时)，校准因子使得下面代码序列中的Elapsed方法的返回值为0。

t-＞Start()；

SMX_U64 x＝t-＞Elapsed()；//here x＝0

采用缺省校准因子，是计算一个操作所用时间的好方法。在下面例子给出的操作之前，可以加入一个Start方法的调用，之后可以加入一个Elapsed方法的调用。

...

t-＞Start()；

//do some work here

printf(″Testing...\n″)；

//

SMX_U64 x＝t-＞Elapsed()；//here x＝time spent printing...

...

如果缺省的校准系数不满足要求，可以调用SetElapsedCalFactor方法来改变校准系数。

SMXJU64 WaitUntil(SMXJJ64 delta)

WaitUntil方法是实现上述消耗函数的一个程序范例。这个方法从Start方法最后一次被调用开始计算一个前向delta，并且在一个紧缩循环中等待，直到时间戳等于或者超过计算的截止时间。

此方法提出了两个可改变的选项：一个用来调节执行时间(平均循环误差)的校准系数，一个根据它的值使能/禁止该方法的使能标记。校准系数可以通过SetWaitUntilCalFactor方法改变，使能标记可以通过Enable和Disable方法改变。根据一个实施方案，使能标记的缺省值为假(WaitUnti方法被禁止)下面的代码实例实现WaitUntil方法：

1. xor eax，eax

2. cpuid ；同步

3. ；；；；；；；；；；；；；；；；；；；；；；；；；；；

4. mov edx，this ；这是必须的！

5. ；；；

6. lea eax，delta ；取回′delta′参数

7. mov ecx，[eax] ；ebx:ecx＝delta

8. mov ebx，[eax+4]

9. ；；；

10. movzx eax，isEnabled ；检查方法是否可用

11. or eax，eax

12. cmovz ecx，eax ；如果不可用，ebx:ecx＝0-＞don′t

loop ！

13. cmovz ebx，eax

14. ；；；

15. xor eax，eax ；将eax用于0寄存器

16. ；；；

17. sub ecx，[edx+wCF+0] ；ebx:ecx＝delta-calfactor

18. sbb ebx，[edx+wCF+4]

19. ；；；

20. cmovc ecx，eax ；如果(delta-calfactor)＜0，

ebx:ecx＝0！

21. cmovc ebx，eax

22. ；；；

23. add ecx，[edx+marker+0] ；ebx:ecx＝marker+delta-

calfactor

24. adc ebx，[edx+marker+4]

25. ；；；；；；；；；；；；；；；；；；；；；；；；；；；

26.lbl0:rdtsc ；读取CPU时间戳到edx:eax

27. sub eax，ecx

28. sbb edx，ebx ；edx:eax＝CLK-(marker+delta)

＝循环错误

29. jc lbl0 ；当误差为负时循环

列出的代码按以下方式执行：第1行和第2行同步执行流程；第4行找回一个指向当前目标的指针(this)；第6行和第8行载入被请求的等待时间；第10行和第11行检查此方法是否被使能；如果方法未被使能，第12行和第13行将被请求的时间变为0；第17行和第18行将编程的校准系数从请求的等待实践中减去；如果结果为负，第20行和第21行将前面的计算调整为0。第23行和第24行计算最终的时间戳；最后，第26行到第29号的循环等待直到达到计算出的时间戳。返回值是无符号64-bit值，表示CPU时钟中测量到的循环误差。

在校准时间，WaitUntil方法用变化的数据值运行。这一程序得到两个感兴趣的数字，即此方法执行所需的最小时间(开销)和循环误差。缺省校准系数是开销和循环误差的一半的和。

可利用下面的代码实例，执行上述的WaitUntil方法：

...

t-＞Start()；

RunCodeHere()；

t-＞WaitUntil(computedDelay)；

...

在上述例子中，如果计算的延时的等价时间比RunCodeHere函数的最大执行时间长，上述引用是一个如前面所述的确定性操作O_D。另一方面，如果RunCodeHere函数的执行时间比计算的延时值的等价时间长，此操作不是确定性的，由Start和WaitUntil方法实现的RunCodeHere函数周围的封装就没有作用了。下面列出的是决定计算的延时的值使上述代码为确定性的方法

SMX_U64 WaitUntilEx(SMXJU64 delta)

与WaitUntil方法相反，这里被称作WaitUntilEx的方法利用操作***(例如，Windows或者INtime操作***函数)来增加消耗时间。这一方法可以用来允许开发者等待较长的时间段(例如，100ms)，给操作***提供一些时间完成它的工作，比如移动鼠标，在网络上交换包等等，同时仍保持对所花时间的控制。使用上面的WaitUntil方法，等待正确的时间戳的紧缩循环锁住CPU，且不存在外在行为，给用户一个CPU被悬挂的假象。

WaitUntilEx方法将消耗的时间分为两部分：一部分是由操作***利用它的睡眠函数之一(例如Windows中的Sleep函数和INtime中的knRtSleep函数)消耗的。第二部分可能是由WaitUntil方法消耗的以对所花的总时间提供更好的控制。返回值是WaitUntil方法返回的循环误差。

SMXJJ64 Wait(SMXJJ64 elks)

这个方法可以通过如下例子实现：

Start()；

return WaitUntil(elks)；

Wait方法等待指定数目的时钟(elks)被消耗。返回值是WaitUntil方法返回的循环误差。

SMXJJ64 WaitEx(SMXJJ64 elks)

本方法可以通过如下例子实现：

Start()；

return WaitUntilEx(clks)；

WaitEx方法等待指定数目的时钟(elks)被消耗。返回值是WaitUntilEx方法返回的循环误差。

SMXJJ64 GetElapsedCalFactor(void)

此方法返回一个无符号64-bit值，表示CPU时钟被Elapsed方法用作校准系数的数目。

void SetElapsedCalFactor(SMXJJ64 newCF)

此方法将Elapsed方法使用的校准系数设置为无符号64-bit值，以参数方式传递。参数的期望单位为CPU时钟个数。

void ResetElapsedCalFactor(void)

ResetElapsedCalFactor方法恢复Elapsed方法所使用的原始校准系数。当前校准系数丢失。

SMXJJ64 GetWaitUntilCalFactor(void)

此方法返回一个无符号64-bit值，表示被WaitUntil方法用作校准系数的CPU时钟个数。

void SetWaitUntilCalFactor(SMX_U64 newCF)

此方法将WaitUntil方法使用的校准系数设置为无符号64-bitz值以参数方式传递。参数的期望单位为CPU时钟个数。

void ResetWaitUntilCalFactor(void)

ResetWaitUntilCalFactor方法恢复WaitUntil方法使用的原始校准系数，当前的校准系数丢失。

SMX_U64 GetCPUFrequency(void)

这个静态方法以Hertz为单位返回校准过程中建立的CPU频率。返回值为无符号64-bit数。

SMX_U64 GetKernelTickClk(void)

此静态方法GetKernelTickClk返回一个无符号64-bit数，表示等于一个内核时钟周期的CPU时钟数目。在Windows操作***中，内核时钟周期为10ms，在INtime环境下，内核时钟周期可能是以下值之一100us，200us，250us，500us，1ms，2ms，5ms，and10ms。

bool Islnitialized(void)

此静态方法可用作确认校准结果。如果校准失败，类的对象可能表现出不稳定的行为，不应采用。如果最终的校准合适，此方法返回真值，否则返回假值

void Enable(void)

此静态方法将使能属性设置为真。此属性可以用于WaitUntil方法，来使能/禁止它的功能。在INtime环境中运行时，此方法也使内核调度程序停止。根据一个实施方案，缺省情况下WaitUntil被禁止。

void Disable(void)

此静态方法将使能属性重置为假，此属性用于WaitUntil，使能、禁止它的功能。更多信息参见WaitUntil方法描述。在INtime环境中运行时，此方法也将内核调度程序重启。根据一个实施方案，缺省情况下WaitUntil被禁止。

bool IsEnabled(void)

此静态方法检查WaitUntil方法的状态，如果它被使能则返回真，否则返回假

SMX_U64 GetLoopError(void)

如上面WaitUntil方法的代码例子所示，在时间戳计时器等于或超过这个值(marker+delta-calfactor)一个循环误差时，第26-29行的循环结束。在校准过程中，WaitUntil方法可以利用不同的值运行，以得到数据参数，得到在校准过程中建立的，以CPU时钟为单位的循环误差的谱值。

SMX_U64 GetWaitUntilOverhead(void)

此方法返回一个无符号64-bit值，代表WaitUntil方法的最小执行时间的CPU时钟数目。

void DisableAllInterrupts(void)

此静态方法禁止除当前启动的中断之外的所有中断。它可以用来确保正在执行的程序的确定性行为不会被外部事件影响。在任何I/O操作或者操作***调用之前，可以用Restorelnterrupts方法恢复中断。

void Restorelnterrupts(void)

此静态方法启动在上述DisableAllInterrupts被调用时出现的中断。

bool CalibrateTiming(void)

此静态方法运行校准处理，确定Elapsed和WaitUntil方法使用的校准参数以及时钟频率。如果此方法返回真值，校准成功，否者此方法返回假值。

SMX_U64 Clk2Time(SMX_U64 elks，enum TimeUnits unit)

此静态方法用来将CPU时钟按指定的时钟单位转变为时间。可用的时间单位有，例如，秒，(SEC)，毫秒(MTLLISEC)，微妙(MICROSEC)，纳秒(NANOSEC)和皮秒(PICOSEC)。

SMX_U64 Time2Clk(SMXJJ64 time，enum TimeUnits unit)

此静态方法用来将指定时间单位的时间转换为CPU时钟数。可用的时间单位有，例如秒(SEC)，毫秒(MTLLISEC)，微妙(MICROSEC)，纳秒(NANOSEC)和皮秒(PICOSEC)。

void FlushCaches(void)

此静态方法可用于刷新所有缓存。此方法可在基准之前使用，来推出最坏情况。

创建一个确定性驱动的步骤范例

创建一个确定性驱动通常是一个需要很多时间测试的处理，并且通常花费很长时间。每个暴露出来的API在利用不同参数运行时应该被定时。为了帮助软件开发者设计一个确定性驱动，下面介绍一个包含几个指导方针，用来建立一个的确定性驱动的方法：

第1步-算法选择

在开发过程中，驱动编写者必须十分仔细地选择算法。由于建立一个确定性驱动包括在其执行时间上加入一些″垫子″，用来补偿变化，因此选择一个稳定的快速的算法十分重要。

采用相似的(如果不相同)执行时间建立执行路径，这被称作平衡的执行。此方法通常难以实现，但是一旦实现将非常有效。一个说明此平衡执行技术的例子如下所示：

Instead of using: Use:

int x＝2； int x；

if(a＜b) if(a＜b)

{ {

x＝5； x＝5；

} }

else

{

x＝2；

}

在前面的例子中，如果比较语句具有很强的关联性，比如a通常大于或者小于b(不平衡的执行时间)，则此方法没有实际效果，应优先采用执行时间优化：

If a usually is less than b: if b usually is less than or

equal a:

int x＝2； int x＝5；

if(a＜b) if(b＜＝a)

{ {

x＝5； x＝2；

} }

另外一种提供平衡执行的优化包括彻底删除条件语句(if语句)。与前例相同的操作可以用如下实例实现：

int x＝5&(-int(a＜b))|2&(-int(b＜＝a))；

这种解决方案比前述情形更为复杂，但是此方案具有一致的执行时间，并且没有分支语句。需要指出的是当使用条件分支语句的时候，比如if语句，则每当条件失败时，执行时间中会增加一个惩罚值。

第2步执行时间分析

一旦小心选择了算法，则应该根据输入参数分析一下执行时间。下面的两个例子表明了不同API的输入如何影响执行时间：

int func1(int x) int func2(int x)

{ {

return x+2； int value＝0；

}

for(int i＝1；i＜＝x；i++)

{

value+＝i；

}

return value；

}

从逻辑上看，上述函数中func1的执行时间是常数级别，和输入参数无关；而func2的执行时间一定会依赖于输入参数的变化而改变。类似func1的函数在这里被称为简单函数；而类似func2的函数被称作复杂函数。当一个给定函数的执行时间不会受到输入参数的强烈影响时，则可以把它当作一个简单函数。例如，如果前面给出的func2函数中，如果value的值总是小于10，则将其执行时间模型化为简单函数还是较为方便的。注意func2在输入参数小于或者等于0的时候，表现为简单函数；并且随着x的增加，函数的执行时间呈现线性增长。

第3步-基准

不幸的是，对于函数逻辑的简单分析无法确定其执行时间。另一方面，这类分析对于设计正确的基准测量过程是重要的。如前一节所述，简单函数不受外界激励的影响，而复杂函数则正好相反。几个简单的基准函数如下所述。

简单函数的基准化

简单函数的基准化可用下面这个函数来完成。需要指出的是由于输入参数并不重要，因此可以选择各种合法参数。

1. SMX_Timing::Disable()；

2.

3. for(int j＝0；j＜MAX_SAMPLES；j++)

4. {

5. SMX_Timing::FlushCaches()；

6. t0-＞Start()；

7. //add here the operation to be timed

8. t-＞Start()；

9. result＝func1(anyValidValue)；

10. t-＞WaitUntil(anyValue)；

11. //end of operation

12. samples[j]＝t0-＞Elapsed()；

13. }

前述基准函数的执行步骤如下：第1行禁用WaitUntil方法(和确定性引擎)，这样在第8、9、10行执行的确定性操作O_D就成为常规运算(非确定性)了。由于WaitUntil方法被禁用，anyValue的值就不重要了。

第5行清除了所有的缓存(代码和数据)以得到执行时间的最差值；第6行和第12行测量func1以及由8、9、10组成的确定性测试封装的执行时间。注意t0测量了由第8、9、10行组成的确定性操作O_D的总执行时间。

由于确定性引擎已被禁用，第12行得出的测量值包括了func1的执行时间和确定性引擎(在公式(2)和(3)中的E)的固有时间开销。

在上述代码段执行结束后，可以通过搜索一组样本得出一个最大值。根据一个实施方案，可以收集一组执行时间样本并在收集的数据上执行统计分析。特别地，通过检查执行时间峰值差异(抖动)和平均执行时间不仅更利于理解函数行为，而且也可以指出前述分析中的错误。

一旦被基准化的函数的执行时间的最大值被定义，变量computedDelay可被定义，且下面的代码范例可以被运行，以确定预先设定的行为：

1. SMX_Timing::Enable()；

2.

3. for(int j＝0；j＜MAX_SAMPLES；j++)

4. {

5. t0-＞Start()；

6. t-＞Start()；

7. result＝func1(j)；

8. t-＞WaitUntil(computedDelay)；

9. samples[j]＝t0-＞Elapsed()；

10. }

将采样阵列用图表示，应该得到一条变化较小的平坦曲线。需要记住的一点是，WaitUntil方法中有一个固有误差，并期望此误差在循环误差范围内。为了确定循环误差的值，开发者可以调用上述的GetLoopError方法。注意，在前面的例子中，函数funl通过变量j被调用，作为确定原分析是否正确的安全测试。

复杂函数的基准化

复杂函数的基准化更困难。在上面列出的样本函数func2中，需要创建一个2维矩阵。一维表示可能的输入值(x值)，另一维表示这一指定的输入值(固定的x)对应的采样。由于func2只有一个依赖量(x参数)。可以创建一个2维矩阵。通常，一维用来储存依赖变量，另一维用来储存所有变量固定之后的采样值。下面的清单是函数func2基准化程序的范例：

1. SMX_Timing::Disable()；

2.

3. for(int j＝0，idx＝0；j＜MAX_SAMPLES；j++)

4. {

5. for(int i＝MIN；i＜MAX；i+＝STEP，idx++)

6. {

7. SMX_Timing::FlushCaches()；

8. t0-＞Start()；

9. t-＞Start()；

10. result＝func2(i)；

11. t-＞WaitUntil(anyValue)；

12. samples[idx]＝t0-＞Elapsed()；

13. }

14. }

上面的清单和用于简单函数的清单的主要区别在于，增加了另一个for循环来变化函数func2的输入x。仿真不必覆盖可能值的整个范围，但是应该运行所有的该函数被基准化的所有执行路径。由于当输入参数小于或等于0及为正时，func2具有不同的行为，上述基准化程序应该将MIN的值设置为小于零的某值，将MAX设置为大于0的某值。每条执行路径正确的(最小的)点数取决于函数，开发者需要执行基准化，直到在执行时间观察到一个行为模式

由于函数对每个x值有一个最大值，开发者具有两个选择：创建一个表，将每一个可能的输入x与为这个指定输入建立的最大值关联，或者创建一个函数，表示执行时间随输入x的变化。第一个选择通常不可行，因为输入范围可能很大，将表装入存贮器是不可行的。第二个选择更加难于实现，但是是通常使用的方法。

从上面的分析我们可以猜测，对于小于或等于0的x值，函数func2具有恒定的执行时间，对于大于0的X值，其执行时间为斜升曲线。模仿这一行为的函数可以是：

1. SMX_U64 executionTime(int x)

2. {

3. SMX_U64 ns＝A*(x&(-int(x＞0)))+B；

4. SMX_U64 clkTicks＝SMX_Timing::Time2Clk(ns，

5. SMX_Timing::NANOSEC)；

6. //returns value in clock ticks

7. return clkTicks；

8. }

上面的函数按如下方法执行：如果x小于或等于0，逻辑操作求得的值为0，executionTime(执行时间)函数返回Bns。如果x大于0，执行时间以每单位x值Ans的速度增加。例如，如果x设为100，执行时间为(100*A+B)ns。A和B的值在基准化执行之后确定。注意，WaitUntil方法希望执行以时钟为单位的值，所以executionTime函数中调用Time2Clk方法执行到时钟单位的转换。基准化程序可以改变用来计算新的结构。变量anyValue可以用下面给出的函数调用替代

1. SMX_Timing::Disable()；

2.

3. for(int j＝0，idx＝0；j＜MAX SAMPLES；j++)

4. {

5. for(int i＝MIN；i＜MAX；i+＝STEP，idx++)

6. {

7. SMX_Timing::FlushCaches()；

8. t0-＞Start()；

9. t-＞Start()；

10. result＝func2(i)；

11. t-＞WaitUntil(executionTime(i))；

12. samples[idx]＝t0-＞Elapsed()；

13. }

14. }

注意，利用新的函数调用计算执行时间，总体执行增加了。这一现象不影响确定性操作O_D，只是增加他的执行时间，因为在WaitUntil方法执行之前调用了executionTime函数。

现在开发者有了一个基准化程序，可以定义A和B的值。一个目的是创建一组值，当它们替换到函数executionTim中时，此函数返回的结果总比实际的执行时间(非确定性时间)长。为了确保所选择的一组值满足这一目的，基准化程序可能被按与简单函数funl的基准化执行相似的方法再次执行。

需要注意，executionTime函数计算出的时间明确地以ns为单位计算，然后转换为时钟数。这是因为，根据一个实施例，一个ATE***期望的特性之一是相关性。

当两个***对比时，一个不可避免的差别是CPU时钟频率。甚至即便规格匹配，每个CPU的有效速度都不同。此外，由于在测试应用的整个有效时间内，需要保持执行时间恒定，有必要根据很多因素，例如故障和安装的基本扩展，对计算机进行常规升级。考虑到这一点，开发者可以理解为什么以时钟数为单位测量执行时间不是好的方法。

第4步-整合一个时间表

在SMX体系中，每个驱动具有至少一个时间表。理论上，必须为每个面向用户的不同的计算机创建一个时间表。

时间表以DLL的形式实现，载有数据表，执行时间模型(时间函数)来表示复杂***的时间行为和一些标准函数，来报告此时间表的信息。

根据一个实施方案，数据表是一个阵列，其中每个元素通过下面例子中的结构表示：

struct SMX_TimingTableEntry

{

void*pFunc；

SMX_U64 time；

enum SMX_Timing::TimeUnits unit；

SMX_U64 clockTicks；

}；

在上述例子的结构中，pFunc是一个空指针，表示被复杂函数调用的时间函数的地址；time表示简单函数所用的执行时间；unit是field time使用的单位；clockTicks包括这对参数(time，unit)到当前CPU时钟频率的转换结果。注意，这个转换步骤在DLL载入之后只出现一次。

时间函数可以具有任意个参数，但是它们应该，例如，返回以时钟数为单位的执行时间。事实上，如果可能的化，时间函数速度应该快，因为此函数使用十分频繁。在一个实际的驱动中，如果函数按和下面相似的方式实现，上面列出的executionTime函数可能更有用、更快。

static const SMX_U64 A_time＝<some value>；

static const SMX_U64 B_time＝<some value>；

static SMX_U64 A＝0；

static SMX U64_B＝0；

static SMX_U64 executionTime(int x)

{

return A*(x&(-int(x＞0)))+B；

}

这里，值A和B在DLL载入时从时间转换为时钟数。利用这个方法，耗时很多的转换步骤只需执行一次。

下面的时间表表示一个例子，其中列出了一个简单函数和一个复杂函数。

struct SMX_TimingTableEntry timingTable[]＝

{

//function address time unit clock ticks

//////////////////////////////////////////////////////////

{ 0，500，SMX_Timing::NANOSEC， 0}，// 0

{ executionTime， 0，SMX_Timing::NANOSEC， 0} // 1

}；

时间表DLL可以包括3个例程，来提供关于该时间表的信息，它们可以是不变的，与下面列出的类似。

extern″C″＿declspec(dllexport)struct SMX_TimingTableEntry

*SMXGetTableAddress(void)

{

return timingTable；

}

extern″C″＿declspec(dllexport)int SMXGetElementSize(void)

{

return sizeof SMX_TimingTableEntry；

}；

extern″C″＿declspec(dllexport)int SMXGetNumberOfElements(void)

{

return sizeof timingTable/sizeof SMX TimingTableEntry；

}；

第一个例程返回时间表地址，第二个返回时间表元素长度，最后一个返回时间表中建立的元素的个数。

作为一个标准程序，DLL main(SMX_DLL_MAIN)包括将所有表示时间的常量转换为时钟数的必要的代码。下面的列表描述了一种实现方法：

#pragma warning(disable:4100)

extern″C″BOOL＿stdcall SMX_DLL_MAIN(SMX_DLL_HANDLE module，DWORD reason

LPVOID reserved)

{

switch(reason)

{

case SMX_DLL_PROCESS_ATTACH:

for(int i＝0；i＜SMXGetNumberOfElements()；i++)

{

timingTable[i].clockTicks＝SMX_Timing::Time2Clk

(timingTable[i].time，timingTable[i].unit)；

}

A＝SMX_Timing::Time2Clk(A_time，SMX_Timing::<SOME_UNIT>)；

B＝SMX_Timing::Time2Clk(B_time，SMX_Timing::<SOME_UNIT>)；

break；

case SMX_DLL_THREAD_ATTACH:

case SMX_DLL_THREAD_DETACH:

case SMX_DLL_PROCESS_DETACH:

break；

}

return TRUE；

}

#pragma warning(4:4100)

}

在SMX_Timing设计中定义了一个类，帮助开发者管理时间表。类的名字叫做SMX_TimingTableManager，可以被驱动继承。

public:

SMX_TimingTableManager(void)；

-SMX_TimingTableManager(void)；

//

virtual bool IsInitialized(void){return ttm_init；}；

virtual SMX_TimingTableInfo*GetCurrentTimingTableInfo(void){return

pCurrent；}；

virtual bool UpdateDriverTiming(void){return true；}；

//

virtual bool UseTimingTable(char*name＝0)；

virtual SMX_U64 GetTimingTableValue(int index)；

virtual SMX_U64(*GetTimingTableFunction(int index))(...)；

}；

确定性引擎应用

根据一个实施方案，确定性引擎的一个应用是在设计中时间不确定的***中提供确定性行为。使用Intel奔腾类处理器的计算机***在设计上是非确定性的。奔腾处理器采用几级流水线，分支预测算法和内部高速缓存，使得任何特定的指令设置的执行时间依赖于处理器当前的“上下文”(例如，每级流水线上哪些之指令正在被解码，内部高速缓存的内容和安排，等等)。这使得不可能对于任意指定的指令设置，定义一个预先的确定执行时间。可以定义的是最大执行时间。这使得基于奔腾型处理器的***可预测但非确定性。

根据本发明的一个实施方案，如果期望的恒定时间等于或大于最大执行时间，确定性引擎可以使得总执行时间对于任意指定的指令设置恒定。最大执行时间即可以通过分析相关的指令级(并找到它们的最大执行时间)来确定，也可以依据经验通过执行设置在不同的处理器上下文中的指令来确定。

根据本发明的各个实施方案，确定性地执行操作的结果见图6和图7。图6给出了非确定性***的代码执行范例。这些执行可以通过相同的或者不同的计算机实现。如图所示，三种不同的操作可以得到三种总执行时间，t1，t2和t3。一个需要确定性执行的软件***不能依赖与提供执行时间的计算机***的恒定执行时间，如图6所示。

图7给出了通过实现本发明的各个实施方案的一个或多个计算机***执行代码的范例。在所给的范例中，相同的代码段的总执行时间相同，为t。因为对于不同的执行，执行时间恒定，代码实现的操作是可重复的。

例如，确定性引擎可用在图7中称为“DE”对象的两个C++方法实现。Start()方法标记了执行的开始，而Wait()方法保持确定性引擎的运行直到经过时间t。这保证了这组指令的总执行时间总是常数，且等于时间t。

确定性引擎在那些需要保证后续执行时间而非执行速度的场合中有很多应用。这个特性在半导体自动测试设备(ATE)行业中是一个常见功能，尤其是在线性(模拟)和混合设备的测试。在此类***中，需要对被测设备(DUT)提供大量不同输入，并测量DUT对这些输入的反应。根据获得的测试结果来确定DUT可正常工作还是有缺陷的。由于需要测量线性和混合信号***产生的模拟信号，精确测定何时进行测试就显得至关重要了。

图8显示了一个假想设备的输出和两个用来验证此设备到底是否正常工作的测量(M1和M2)。如果在非确定性***中通过软件来测量，则所得测量实施的时间就有不精确之处(抖动)。如果同样的测试软件顺序执行多次(本例中是三次)，测试软件每次运行得到的结果M1和M2就很可能不同，即使设备输出其实每次都一样。

图8显示了和测量执行相关的抖动直接导致了测量值的误差。根据这种时间抖动的程度，测量误差可能大到将一个正常工作的设备误判为不正常工作或者相反。从历史上看，线性和混合型号设备的测试应用必需能够处理这类问题，并且也确实由几种解决方案，但是这些方案要么需要更多的额外测试时间(平均需要很大数量的测试)或者成本(更为复杂的测试硬件)。

如果使用确定性引擎的实施例来精确控制实施测量的时间，则可以消除或者极大减弱时间抖动，这在不显著增加时间、少用复杂测试硬件的情况下，就能够得到更可重复的结果。

能够指定测试实施时间的一个直接结果是，测试应用软件与运行平台的处理器运行速度无关。例如，如果一个测试应用是在某种主频的计算机平台(如2.0GHz)上开发的，则此应用的测量结果就和该处理器速度紧密相关。如果将此测试应用迁移到一个更快的计算机***(比如3.0GHz)上，则所有的测试很可能被比预期速度更快的执行，而这种更快操作的结果是(再次)得到错误的结果。对于***开发人员来说，将一个现有测试应用移植到更快的处理器***将花费大量的时间和成本。

相反，如果测试应用使用了确定性引擎，则所有的测量都会在预先定义的相同时间点获得。这意味着将测试应用移植到更快的处理器***是无需改动的。这个功能使用户只需改进某些选定的测量；而不是移植整个测量应用(通常包括几千个测量)。

通过描述本发明至少一个具体实施例的各个方面，还需要指出基于本发明的描述，会有各种备选、变体和改进。这类备选、变体和改进都是本发明的组成部分，它们都被包括在本发明的精神和范围之内。由此，下列描述和图示仅作为实例。

Claims

1.一种用于执行确定性处理的***，该***包括：

适于执行一个或多个指令的处理实体；以及

适于将一个或多个指令的执行时间调节为恒定值的部件。

2.根据权利要求1所述的***，其中部件适于调节到一个或多个指令的最大执行时间。

3.根据权利要求1所述的***，其中部件适于在一个或多个指令的多次执行中将一个或多个指令的执行时间调节为相同的恒定值

4.根据权利要求3所述的***，其中多个执行出现在不同的计算机***上。

5.根据权利要求4所述的***，其中不同的计算机***具有不同的处理性能。

6.根据权利要求1所述的***，其中部件适用于在预定的时间段内完成的一个或多个指令的执行。

7.根据权利要求1所述的***，其中部件适于等待一段时间，从而将执行时间调节为恒定值。

8.根据权利要求7所述的***，进一步包括时间参考，并且其中部件适于利用时间参考确定相关时间。

9.根据权利要求8所述的***，其中部件适于基于处理器时钟周期的计数值确定相关时间。

10.根据权利要求8所述的***，其中时间参考包括接口，并且其中部件适于通过这个接口得到处理时钟周期的计数。

11.根据权利要求1所述的***，其中部件适于确定用于执行一个或多个指令的时间量，并且适于等待一段时间将执行时间调节为恒定值。

12.根据权利要求9所述的***，其中部件适于根据多个计数值确定消耗的时间。

13.根据权利要求9所述的***，其中计数值是处理器的时间戳计时器

14.根据权利要求13所述的***，其中处理器是奔腾型处理器。

15.根据权利要求1所述的***，其中***是自动测试***的一部分。

16.一种执行确定性处理的计算机实现方法，方法包括以下动作：

在计算机***上执行一个或多个指令；

测量执行动作的执行时间；以及

等待一段时间将执行时间调节为恒定值。

17.根据权利要求16所述的方法，其中等待一段时间的行为包括：在执行之后等待一段时间直到消耗了恒定值的执行时间。

18.根据权利要求16所述的方法，进一步包括测量一个或多个指令的执行，根据测量的动作确定一个或多个指令的最大执行时间。

19.根据权利要求18所述的方法，进一步包括将恒定值设置为最大执行时间。

20.根据权利要求16所述的方法，进一步包括确定一个或多个指令的最大执行时间。

21.根据权利要求20所述的方法，进一步包括将恒定值设置为最大执行时间。

22.根据权利要求16所述的方法，进一步包括在一个或多个指令的多次执行中，将一个或多个指令的执行时间调节为相同的恒定值。

23.根据权利要求22所述的方法，其中多个执行出现在不同的计算机***中。

24.根据权利要求16所述的方法，其中不同的计算机***具有不同的处理性能。

25.根据权利要求16所述的方法，进一步包括在预定的时间段内，在计算机***上进行执行一个或多个指令的动作。

26.根据权利要求16所述的方法，进一步包括等待一段时间将执行时间调节为恒定值。

27.根据权利要求16所述的方法，进一步包括确定相关时间。

28.根据权利要求27所述的方法，进一步包括提供时间参考，以及利用这个时间参考确定相关时间。

29.根据权利要求27所述的方法，进一步包括根据处理器时钟周期的计数值确定相关时间

30.根据权利要求16所述的方法，进一步包括确定用于执行一个或多个指令的时间量，以及等待一段时间将执行时间调节为恒定值。

31.根据权利要求16所述的方法，进一步包括根据多个计数值确定所消耗的时间。

32.根据权利要求16所述的方法，其中计数值是处理器的时间戳计时器

33.根据权利要求32所述的方法，其中处理器是奔腾型处理器

34.根据权利要求16所述的方法，其中此方法由自动测试***实现。