共享可恢复对象：原理、应用与实现
1. 可恢复对象概述
在多任务环境中，为了实现软件容错和“撤销”功能，可恢复对象是一种有效的解决方案。应用程序员可以通过类型扩展来编写包含特定应用数据的可恢复对象。例如：
type Recoverable_Data is new Recoverable.Recoverable_Object with
record
Data : Application_Data;
end record;
需要注意的是，抽象标记类型
Recoverable_Object
是非受限的，因此所有派生类型也必须是非受限的，即可恢复对象不能包含任何受限组件。不过，这个缺点可以通过将
Recoverable_Object
类型设为受限类型，并要求用户为扩展数据类型提供复制过程，或者让用户编写扁平化和重构操作来克服。
为了在多个任务之间共享可恢复对象，显然必须通过引用进行访问，因此提供可恢复性的所有过程都使用引用。
2. 可恢复对象的操作
2.1 New State
procedure New_State (Object : in Recoverable_Object_Ref; New_Object : out Recoverable_Object_Ref);
New_State
过程用于为可恢复对象
Object
建立一个新版本。该对象会被复制，新的版本指针会返回在
New_Object
中。调用此过程的任务会自动添加为对象新版本的参与任务。此过程可能会引发
Already_Created_Subversion
异常，如果
Object
指向的版本已经有相关的子版本。
2.2 Join State
procedure Join_State (Object : in Recoverable_Object_Ref);
如果一个任务想要参与一个已经存在的版本，它必须调用
Join_State
并传递对象版本的引用，这会将该任务添加到参与者列表中。此过程可能会引发
Task_Already_Joined
异常，如果调用任务已经是
Object
指向版本的参与者。
2.3 Commit State
procedure Commit_State (Object : in out Recoverable_Object_Ref; Sync : in Boolean := False);
调用
Commit_State
表示任务已成功完成对
Object
指向对象版本的修改，并希望将这些更改提交到父版本。只有当所有参与任务都提交了更改后，父版本才会更新。如果
sync
参数设置为
true
，该过程会阻塞调用任务，直到所有其他参与任务都给出投票。此过程可能会引发
Task_Never_Joined
和
Object_Discarded
异常。
2.4 Discard State
procedure Discard_State (Object : in out Recoverable_Object_Ref);
使用
Discard_State
，任务可以取消对
Object
指向对象版本的所有更改。一旦一个参与任务调用了
Discard_State
，该版本的状态将被丢弃，而不管其他参与任务的决定如何。此过程可能会引发
Task_Never_Joined
异常。
2.5 Current Status
function Current_Status (Object : in Recoverable_Object_Ref) return Object_Status_Type;
该过程允许参与者获取
Object
指向对象版本的当前状态信息。可能的结果如下：
-
Discarded
：表示有参与者已经调用了
Discard_State
。
-
Committing
：表示所有其他参与者都调用了
Commit_State
。
-
Undecided
：其他情况。
3. 数字图像处理示例
3.1 图像处理简介
当前的数字图像增强应用（如 Adobe Photoshop）提供了各种各样的滤镜，包括图像锐化、柔化、风格化、变形、去除灰尘和划痕、调整亮度、颜色调整、添加噪声、应用纹理等。滤镜可以看作是应用于图像每个像素的函数，其结果像素取决于原始像素、周围像素、图像的其他全局属性以及滤镜的参数。
一些滤镜使用非常简单的函数（如反转图片），而另一些则可能非常复杂。图像恢复滤镜（如边缘检测或降噪滤镜）使用离散傅里叶变换将图像分解为周期性结构，将图像从空间域转换到频率域，这样可以轻松去除图像中的某些频率，因为噪声通常在高频范围内。最后，可以使用逆傅里叶变换重构空间图像。
3.2 性能考虑
计算具有复分量的 M × N 矩阵的二维傅里叶变换的通用公式为：
[F(u, v) = \frac{1}{M} \sum_{m = 0}^{M - 1} \sum_{n = 0}^{N - 1} e^{-j2\pi(\frac{mu}{M} + \frac{nv}{N})}]
直接应用此公式的计算成本非常高。如果 M = N，图像的每个像素需要 (N^2) 次复数乘法和 (N^2 - 1) 次复数加法，整个图像的算法复杂度为 (N^4)。通过数学变换和常量预计算，复杂度可以降低到 (N^2 \log N)，但仍然需要相当大的计算量。
随着个人计算机领域多处理器系统的出现，当前的图像处理应用开始利用额外的处理能力来提高滤镜的性能。下面的编程示例将说明如何在多任务环境中使用可恢复对象来实现软件容错和“撤销”功能。
3.3 示例代码
3.3.1 定义图像数据类型
with Recoverable;
use Recoverable;
package Recoverable_Picture is
subtype Color_Span is Natural range 0 .. 255;
type Pixel is record
Red : Color_Span := 0;
Green : Color_Span := 0;
Blue : Color_Span := 0;
Alpha : Color_Span := 0;
end record;
type Picture is array (Integer range <>, Integer range <>) of Pixel;
type Recoverable_Picture (Top : Integer; Left : Integer; Bottom : Integer; Right : Integer) is new Recoverable_Object with
record
Image : Picture (Left .. Right, Top .. Bottom);
end record;
type Recoverable_Picture_Ref is access all Recoverable_Picture'Class;
end Recoverable_Picture;
3.3.2 实现“撤销”功能的主程序
with Recoverable;
use Recoverable;
with Recoverable.Picture;
use Recoverable.Picture;
with Ada.Text_IO;
use Ada.Text_IO;
procedure Photoshop is
Original_Picture : Recoverable_Picture_Ref;
Filtered_Picture : Recoverable_Picture_Ref;
type Square is record
Top : Integer := 0;
Left : Integer := 0;
Bottom : Integer := 0;
Right : Integer := 0;
end record;
Number_Of_Processors : constant Positive := 5;
Image_Square : constant Square := (-4, -3, 4, 3);
task type Filter_Task;
task body Filter_Task is separate;
begin
Original_Picture := new Recoverable_Picture (Image_Square.Top, Image_Square.Left, Image_Square.Bottom, Image_Square.Right);
New_State (Recoverable_Object_Ref (Original_Picture), Recoverable_Object_Ref (Filtered_Picture));
declare
Tasks : array (1 .. Number_Of_Processors) of Filter_Task;
begin
null;
end;
if Current_Status (Recoverable_Object_Ref (Filtered_Picture)) /= Committing then
Discard_State (Recoverable_Object_Ref (Filtered_Picture));
Alert_User;
else
if User_Accepts_Result then
Commit_State (Recoverable_Object_Ref (Filtered_Picture));
else
Discard_State (Recoverable_Object_Ref (Filtered_Picture));
end if;
end if;
end Photoshop;
3.3.3 滤镜任务的实现
task body Filter_Task is
Source_Picture : Recoverable_Picture_Ref := Get_Source_Picture;
Dest_Picture : Recoverable_Picture_Ref := Get_Dest_Picture;
Subregion : Square := Get_Subregion;
begin
Join_State (Recoverable_Object_Ref (Dest_Picture));
for Y in Subregion.Top .. Subregion.Bottom loop
for X in Subregion.Left .. Subregion.Right loop
Dest_Picture.Image (X, Y) := Filter_Pixel (Source_Picture.Image, X, Y);
end loop;
end loop;
Commit_State (Recoverable_Object_Ref (Dest_Picture));
exception
when others =>
Discard_State (Recoverable_Object_Ref (Dest_Picture));
raise;
end;
2.4 操作步骤总结
| 操作 | 步骤 |
|---|---|
| New State |
1. 调用
New_State
过程，传入原对象引用和新对象引用。
2. 系统复制原对象，新对象指针返回。 3. 调用任务自动成为新对象版本的参与任务。 |
| Join State |
1. 调用
Join_State
过程，传入对象版本引用。
2. 任务加入参与者列表。 |
| Commit State |
1. 调用
Commit_State
过程，传入对象引用和同步标志。
2. 若同步标志为
true
，任务等待其他参与者投票。
3. 所有参与者提交更改后，父版本更新。 |
| Discard State |
1. 调用
Discard_State
过程，传入对象引用。
2. 该任务对对象版本的更改被取消。 |
| Current Status |
1. 调用
Current_Status
函数，传入对象引用。
2. 获取对象版本的当前状态。 |
2.5 操作流程图
graph TD;
A[开始] --> B{选择操作};
B -->|New State| C(调用 New_State 过程);
C --> D(复制对象，新对象指针返回);
D --> E(调用任务成为参与者);
B -->|Join State| F(调用 Join_State 过程);
F --> G(任务加入参与者列表);
B -->|Commit State| H(调用 Commit_State 过程);
H --> I{同步标志为 true?};
I -->|是| J(等待其他参与者投票);
I -->|否| K(继续);
J --> K;
K --> L(所有参与者提交，父版本更新);
B -->|Discard State| M(调用 Discard_State 过程);
M --> N(更改取消);
B -->|Current Status| O(调用 Current_Status 函数);
O --> P(获取当前状态);
3. 图像处理示例
3.1 图像处理简介
在数字图像处理中，滤镜是一种常用的工具。它可以对图像的每个像素进行处理，从而改变图像的外观和特性。例如，Adobe Photoshop 提供了丰富的滤镜，包括图像锐化、柔化、风格化等。
滤镜的处理结果取决于多个因素，如原始像素值、周围像素值、图像的全局属性以及滤镜的参数。一些简单的滤镜（如反转图片）只需要进行简单的计算，而复杂的滤镜（如图像恢复滤镜）则需要使用离散傅里叶变换等复杂的数学方法。
3.2 性能考虑
计算二维傅里叶变换的复杂度较高，直接应用公式的复杂度为 (N^4)，通过优化可以降低到 (N^2 \log N)。随着多处理器系统的发展，图像处理应用可以利用额外的处理能力提高性能。
3.3 示例代码
3.3.1 定义图像数据类型
with Recoverable;
use Recoverable;
package Recoverable_Picture is
subtype Color_Span is Natural range 0 .. 255;
type Pixel is record
Red : Color_Span := 0;
Green : Color_Span := 0;
Blue : Color_Span := 0;
Alpha : Color_Span := 0;
end record;
type Picture is array (Integer range <>, Integer range <>) of Pixel;
type Recoverable_Picture (Top : Integer; Left : Integer; Bottom : Integer; Right : Integer) is new Recoverable_Object with
record
Image : Picture (Left .. Right, Top .. Bottom);
end record;
type Recoverable_Picture_Ref is access all Recoverable_Picture'Class;
end Recoverable_Picture;
3.3.2 主程序
with Recoverable;
use Recoverable;
with Recoverable.Picture;
use Recoverable.Picture;
with Ada.Text_IO;
use Ada.Text_IO;
procedure Photoshop is
Original_Picture : Recoverable_Picture_Ref;
Filtered_Picture : Recoverable_Picture_Ref;
type Square is record
Top : Integer := 0;
Left : Integer := 0;
Bottom : Integer := 0;
Right : Integer := 0;
end record;
Number_Of_Processors : constant Positive := 5;
Image_Square : constant Square := (-4, -3, 4, 3);
task type Filter_Task;
task body Filter_Task is separate;
begin
Original_Picture := new Recoverable_Picture (Image_Square.Top, Image_Square.Left, Image_Square.Bottom, Image_Square.Right);
New_State (Recoverable_Object_Ref (Original_Picture), Recoverable_Object_Ref (Filtered_Picture));
declare
Tasks : array (1 .. Number_Of_Processors) of Filter_Task;
begin
null;
end;
if Current_Status (Recoverable_Object_Ref (Filtered_Picture)) /= Committing then
Discard_State (Recoverable_Object_Ref (Filtered_Picture));
Alert_User;
else
if User_Accepts_Result then
Commit_State (Recoverable_Object_Ref (Filtered_Picture));
else
Discard_State (Recoverable_Object_Ref (Filtered_Picture));
end if;
end if;
end Photoshop;
3.3.3 滤镜任务
task body Filter_Task is
Source_Picture : Recoverable_Picture_Ref := Get_Source_Picture;
Dest_Picture : Recoverable_Picture_Ref := Get_Dest_Picture;
Subregion : Square := Get_Subregion;
begin
Join_State (Recoverable_Object_Ref (Dest_Picture));
for Y in Subregion.Top .. Subregion.Bottom loop
for X in Subregion.Left .. Subregion.Right loop
Dest_Picture.Image (X, Y) := Filter_Pixel (Source_Picture.Image, X, Y);
end loop;
end loop;
Commit_State (Recoverable_Object_Ref (Dest_Picture));
exception
when others =>
Discard_State (Recoverable_Object_Ref (Dest_Picture));
raise;
end;
3.4 图像处理步骤
| 步骤 | 操作 |
|---|---|
| 1 | 定义图像数据类型。 |
| 2 | 分配原始图像。 |
| 3 | 创建图像的新版本。 |
| 4 | 创建滤镜任务。 |
| 5 | 检查任务是否成功完成。 |
| 6 | 根据用户选择提交或丢弃更改。 |
3.5 图像处理流程图
graph TD;
A[开始] --> B(定义图像数据类型);
B --> C(分配原始图像);
C --> D(创建新版本);
D --> E(创建滤镜任务);
E --> F{任务成功完成?};
F -->|否| G(丢弃更改，提示用户);
F -->|是| H{用户接受结果?};
H -->|是| I(提交更改);
H -->|否| J(丢弃更改);
4. 实现细节
4.1 数据结构
从实现的角度来看，可恢复对象本质上是一个对象版本的双向链表。每个版本包含指向其父版本和子版本（如果存在）的指针、表示版本当前状态的字段以及所有参与任务的任务 ID 列表。
每个版本都有一个关联的受保护对象，提供简单的
Lock
和
Unlock
操作，以防止并发访问。它还定义了一个入口
Wait_For_Participants
，用于在参与者调用
commit_state
并进行同步时阻塞任务。
protected type Recoverable_Object_Lock is
entry Lock (L : in out Lock_Handler; O : in Recoverable_Object_Ref);
procedure Unlock (L : in out Lock_Handler; O : in Recoverable_Object_Ref);
entry Wait_For_Participants;
end Recoverable_Object_Lock;
通过为对象的每个版本使用单独的锁，可以提高并发性。
4.2 并发问题及解决方法
在实现
Discard
和
commit
过程时，需要注意从链表中移除版本的操作，为了防止死锁，必须按从上到下的顺序获取父版本、要移除的版本和子版本的锁。
受保护对象不能直接包含在标记类型中，因为这会使类型受限。为了允许版本的赋值，需要将
Recoverable_Object
类型设为受控类型，通过
Initialize
和
Finalize
过程来分配和释放受保护对象，使用
Adjust
过程来禁止在可恢复对象包外部复制整个版本对象。
procedure Adjust (Object : in out Recoverable_Object) is
begin
if Object.Copy_Allowed then
Object.Copy_Allowed := False;
else
raise Program_Error;
end if;
end Adjust;
4.3 异步传输控制（ATC）问题及解决方法
4.3.1 锁的释放
为了确保在发生 ATC 时，任务持有的所有锁都能被释放，需要在受控对象
Lock_Handler
中保存对象被锁定的事实。在获取锁之前，必须声明
Lock_Handler
类型的实例，并将其引用传递给受保护操作
Lock
。
4.3.2 数据结构的一致性
为了避免在任务操作可恢复对象时被中止而导致内部数据结构不一致，需要在中止延迟区域中执行内部数据结构的修改。可以使用受控类型的
Initialize
、
Adjust
和
Finalize
过程来创建中止延迟区域。
4.3.3 逃兵问题
为了检测逃兵任务（即调用
Join_State
但在调用
Discard_State
或
Commit_State
之前终止或被中止的任务），可以使用受控任务属性来存储任务到目前为止加入的所有可恢复对象的版本。如果任务在未完成操作之前终止，受控属性的
Finalize
过程会通知可恢复对象该任务已逃兵。
5. 总结与展望
可恢复对象为多任务环境中的软件容错和“撤销”功能提供了有效的解决方案。应用程序员可以通过扩展
Recoverable_Object
根类型来编写自己的可恢复对象。在设计可并发访问的可恢复对象时，应优先选择延迟更新方案而不是就地更新方案。
在实现过程中，需要特别注意并发问题和任务中止问题，以避免数据结构损坏和内存泄漏。未来，可以进一步研究如何优化可恢复对象的性能，以及如何将其应用到更多的领域中。
6. 可恢复对象操作异常情况总结
在使用可恢复对象的各项操作时，可能会遇到不同的异常情况，以下是对这些异常情况的总结：
|操作|可能引发的异常|异常说明|
|----|----|----|
|New_State|Already_Created_Subversion|如果
Object
指向的版本已经有相关的子版本，会引发此异常。|
|Join_State|Task_Already_Joined|如果调用任务已经是
Object
指向版本的参与者，会引发此异常。|
|Commit_State|Task_Never_Joined|如果调用任务不是
Object
指向版本的参与者，会引发此异常。|
|Commit_State|Object_Discarded|当
sync
参数设置为
true
，且其他参与任务对
Object
指向的版本调用了
Discard_State
时，会引发此异常。|
|Discard_State|Task_Never_Joined|如果调用任务不是
Object
指向版本的参与者，会引发此异常。|
7. 可恢复对象操作异常处理流程图
graph TD;
A[开始操作] --> B{选择操作};
B -->|New State| C(执行 New_State 过程);
C --> D{是否有子版本?};
D -->|是| E(抛出 Already_Created_Subversion 异常);
D -->|否| F(操作成功);
B -->|Join State| G(执行 Join_State 过程);
G --> H{任务是否已加入?};
H -->|是| I(抛出 Task_Already_Joined 异常);
H -->|否| J(操作成功);
B -->|Commit State| K(执行 Commit_State 过程);
K --> L{任务是否参与?};
L -->|否| M(抛出 Task_Never_Joined 异常);
L -->|是| N{sync 是否为 true 且有任务调用 Discard_State?};
N -->|是| O(抛出 Object_Discarded 异常);
N -->|否| P(操作成功);
B -->|Discard State| Q(执行 Discard_State 过程);
Q --> R{任务是否参与?};
R -->|否| S(抛出 Task_Never_Joined 异常);
R -->|是| T(操作成功);
8. 可恢复对象在不同场景的应用优势
8.1 图像处理场景
在图像处理中，可恢复对象的“撤销”功能非常实用。用户在应用滤镜时，可能会尝试多种不同的滤镜效果，如果对当前效果不满意，可以方便地撤销操作，回到之前的版本。同时，多任务处理可以利用多处理器系统的优势，提高图像处理的性能。例如，在上述数字图像处理示例中，多个
Filter_Task
可以同时对图像的不同区域进行滤镜处理，大大缩短了处理时间。
8.2 数据库操作场景
在数据库操作中，可恢复对象可以用于实现事务处理。当多个任务同时对数据库进行操作时，可恢复对象可以确保操作的原子性和一致性。如果某个任务在操作过程中出现异常，可以通过
Discard_State
操作取消该任务的所有更改，保证数据库数据的正确性。
8.3 游戏开发场景
在游戏开发中，可恢复对象可以用于实现游戏的存档和读档功能。玩家在游戏过程中可能会做出各种决策，当玩家对当前游戏状态不满意时，可以通过“撤销”操作回到之前的游戏状态。同时，多任务处理可以用于并行处理游戏中的不同任务，如角色移动、场景渲染等，提高游戏的流畅度。
9. 可恢复对象性能优化建议
9.1 锁的优化
为了提高可恢复对象的并发性能，可以对锁的使用进行优化。例如，尽量减少锁的持有时间，避免长时间占用锁导致其他任务阻塞。可以采用细粒度锁的方式，为不同的操作或数据区域使用不同的锁，提高并发度。
9.2 数据复制优化
在
New_State
和
commit_state
操作中，需要进行数据的复制。可以通过优化数据复制算法，减少复制时间。例如，采用增量复制的方式，只复制发生变化的数据，而不是整个对象。
9.3 任务调度优化
合理的任务调度可以提高可恢复对象的性能。可以根据任务的优先级和资源需求，对任务进行合理的调度。例如，将优先级高的任务优先分配资源，确保重要任务能够及时完成。
10. 可恢复对象未来可能的发展方向
10.1 与人工智能结合
可恢复对象可以与人工智能算法结合，实现更智能的操作和决策。例如，在图像处理中，可以利用人工智能算法自动选择合适的滤镜，并根据用户的操作历史和偏好进行优化。
10.2 分布式系统应用
随着分布式系统的发展，可恢复对象可以应用于分布式环境中。多个节点可以同时对可恢复对象进行操作，通过分布式锁和一致性协议确保数据的一致性和正确性。
10.3 跨平台应用
可恢复对象可以进一步发展为跨平台的解决方案，支持不同的操作系统和编程语言。这样可以扩大可恢复对象的应用范围，使其在更多的领域得到应用。
11. 总结
可恢复对象是一种强大的工具，为多任务环境中的软件容错和“撤销”功能提供了有效的解决方案。通过合理的设计和实现，可以解决并发访问、任务中止等问题，确保数据结构的一致性和正确性。在不同的应用场景中，可恢复对象都展现出了其独特的优势。未来，可恢复对象有望与更多的技术结合，应用到更广泛的领域中，为软件开发带来更多的便利和创新。同时，通过不断的性能优化和发展，可恢复对象将在软件领域发挥更加重要的作用。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
