1. Overview of AIGA platform

2. Agent Specification Hierarchy
Provides general agent functionality. Mobility, Communication, Cloning. Etc.
Manages the processing location. Keeps track of CPU usage, responds to RFPs, accepts, rejects, and initiates agent migration.
Agent
Represents the human user. Submits and listens for results to queries. HCI with the agent system.
Imposes the contract on agents that take input data, process it, and provide the results.
Provides access to information repositories.
Processing Agent
Location
Client Agent
Data Server Agent
Fulfills the processing requirement with domain specific algorithms.
Provides access to domain specific data.
Geospatial Data Server Agent
Image Processing Agent
Geospatial Processing Agent
Text Processing Agent
Image Data Server Agent

3. From Specification to Implementation
While the bulk of our work remains unchanged
Provides domain specific processing
Domain Specific Agents
We only need to change this…
Abstract Agent Implementation
Provides general agent properties (autonomy, mobility, comms, etc.)
Middleware/Agent Interface
Provides translation from middleware to agent system
Middleware Layer (e.g., Jini, CORBA)
Provides underlying infrastructure.
If we change this…

4. Reference
[1] V. Fay-Wolfe, et al, “Real Time CORBA,” IEEE Trans. On Parallel and Distributed Systems, Vol 11 No 10, October 2000

5. Real time constraints Hard Firm Soft Timing constraints
Potential disastrous consequences: Nuclear reactor failure.
Firm
If constraint is not met, the value derived is 0. Financial apps have such constraints.
Soft
Value of failure to meet constraints decreases, but is still non-negative.
Timing constraints
Earliest start time
Latest start time
Completion deadline
Periodic constraints

6. Figure 3: Period Execution
From [1]
Periodic Execution specifies in each period
Earliest start time
Completion deadline

7. Real time predictability
Timing constraint predictability
Task time must be known
Resource requirements specified
Optimistic, average, pessimistic
Soft: Average; Hard: pessimistic
Scheduling algorithm to assign/allocate resources
Similar to bin packing; NP hard
Typical scheduling algorithms involve assigning priorities to tasks
Preemptive (vs non-premptive): Permits replacement of executing task with a (higher priority) task
Static (vs dynamic): Assignments before run-time
Single (vs multiple) resources: E.g. CPU
Hard (vs soft): Timing constraints info required (pessimistic ?)

8. Real Time Scheduling Algorithms
For a set of independent periodic tasks – rate-monotonic is optimal (i.e. if any algorithm can schedule, then so can rate-monotonic)
Priority based on execution requirements – rate of the periodic tasks
Preemptive, static, single resource scheduling

9. Real time Resource Access Control Algorithm
Typically tasks share resources
Priority inversion – higher priority task waits for lower priority task completion
Priority ceiling protocol – bounds priority inversion and prevents deadlock

10. CORBA Build distributed OO programs
Minimize constraints of address space and object location
Program on one processor invokes a method, even though target method is on another processor and its address is not explicitly in the address space of the client program

11. CORBA specs Interface Definition Language (IDL) Declarative language
Example from [1]
IDL for a sensor_table object
interface sensor_table {
readonly attribute short max_length;
short put(in short index, in long data);
long get(in short index); }
C++ to access sensor table
long retval;
sensor_table *p; Pointer to a remote server with sensor_table object
p = bind(“my sensor table”); Bind pointer to the remote object
retval =p → get(500); Retrieve item with index 500 from sensor_table

12. CORBA specs - 2
Figure 1: Process to Implement CORBA Clients and Servers

13. CORBA specs - 3 Object Request Broker (ORB)
Locating server objects to respond to client request
Naming service: object name → object reference
Trader service: return object reference for object with specified functionality and QoS
Interoperable Object Reference
Connect to the server
Data compatability
Object Adapter: at the server routes it to the active processing entity.
Concurrency. Inactive. Thread.

14. CORBA System Components
Figure 2: Corba system components from [1]

15. CORBA specs - 4 Object Services
Naming: Unique names. Binds name to object.
Trader: Consider QoS in determining binding.
Event: Notification service.
Life cycle: Create, destroy objects.
Persistence: Store objects on disk
Transactions: Collection of atomic operations
Concurrency control: Lock objects
Externalization:
Relationship: Semantic relations between objects.
Internet Interoperability ORB Protocol (IIOP)

16. RT Corba
Project 1 – Mitre
Project 2 – SPAWAR SYSCEN
Project 3 -Tao