1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
|
The framework is organized roughly around these high level component
categories. The sublevels indicate the JAWS components that
participate in the category.
Event Framework
JAWS_Event_Dispatcher
JAWS_Event_Completer
JAWS_Event_Result
Input/Output Events
JAWS_IO
JAWS_IO_Impl
JAWS_Asynch_IO
JAWS_Synch_IO
JAWS_Reactive_IO
Timing Events
JAWS_Timer
JAWS_Timer_Impl
JAWS_Task_Timer
Protocol Framework
JAWS_Protocol_Handler
JAWS_Protocol_State
Concurrency Framework
JAWS_Concurrency
JAWS_Concurrency_Impl
JAWS_THYBRID_Concurrency
JAWS_TPOOL_Concurrency
JAWS_TPR_Concurrency
The Event Framework:
The JAWS_Event_Dispatcher remains hidden to the application
developer. It is initialized from the main program which is built
within the jaws3 subdirectory, and uses ACE_Reactor and
ACE_Proactor.
The JAWS_Event_Completer is a callback helper class that is used by
the JAWS_Event_Dispatcher. A completer is passed into the Event
Framework whenever an application developer wants to initiate an
event. When the event completes, the completer is called for
notification.
The JAWS_Event_Result is a class that describes the result of the
event for the completer when the completer gets called back.
Input/Output Events
The JAWS_IO class bridges IO event dispatching methods to the
JAWS_IO_Impl abstraction. It delegates its IO interfaces to
corresponding methods in JAWS_IO_Impl.
JAWS_Asynch_IO, JAWS_Synch_IO, and JAWS_Reactive_IO all derive from
JAWS_IO_Impl. The usage API for these classes follows an
asynchronous usage interface. This enables an application to
experiment with different underlying IO implementations to see how
it impacts performance without redesigning/rewriting the entire
application.
Timer Events
The JAWS_Timer class bridges timer dispatching methods to the
JAWS_Timer_Impl abstraction.
JAWS_Task_Timer derives from JAWS_Timer_Impl, and uses a task
coupled with an ACE_Timer_Wheel to implement timers.
Protocol Framework
The JAWS_Protocol_Handler plays the role of Context in the State
pattern, while the JAWS_Protocol_State plays the role of State. The
JAWS_Protocol_Handler's service() method delegates to the service()
method of an associated JAWS_Protocol_State. In addition, the
JAWS_Protocol_Handler also derives from JAWS_Event_Completer.
The idea is that the application developer will derive from
JAWS_Protocol_State to fill out the programmatical details of their
protocol. At the end of the state, an asynchronous event will be
initiated, and the state returns the control of the thread back to
the framework. When the event completes, the associated
JAWS_Protocol_Handler is called back, and it then triggers a call
into the JAWS_Protocol_State's transition() method. This method
is to return the next state or the protocol. The event completion
callback then enqueues itself with one of the concurrency
implementations of the Concurrency Framework.
Concurrency Framework
The JAWS_Concurrency class bridges concurrency mechanisms to the
JAWS_Concurrency_Impl abstraction.
JAWS_THYBRID_Concurrency, JAWS_TPOOL_Concurrency and
JAWS_TPR_Concurrency derive from JAWS_Concurrency_Impl. They are
active objects that dequeue JAWS_Protocol_Handlers and call into
their service() methods.
|
