|
DataMuseum.dkPresents historical artifacts from the history of: Rational R1000/400 |
This is an automatic "excavation" of a thematic subset of
See our Wiki for more about Rational R1000/400 Excavated with: AutoArchaeologist - Free & Open Source Software. |
top - download
Length: 25432 (0x6358)
Types: TextFile
Notes: R1k Text-file segment
└─⟦8527c1e9b⟧ Bits:30000544 8mm tape, Rational 1000, Arrival backup of disks in PAM's R1000
└─ ⟦cfc2e13cd⟧ »Space Info Vol 2«
└─⟦ca579be70⟧
└─⟦this⟧
with system;
with unchecked_conversion;
with unsigned_types;
with v_i_krn_trace;
with v_i_types; use v_i_types;
package v_i_trace is
pragma suppress (ALL_CHECKS);
pragma suppress (EXCEPTION_TABLES);
pragma not_elaborated;
pragma local_access;
subtype address_sized_type is v_i_krn_trace.address_sized_type;
subtype microseconds is v_i_types.universal_scalar;
type byte is range 0..255;
for byte'size use 8;
----------------------------------------------------------------------------
-- Help in logging arguments.
function to_a is new
unchecked_conversion(address_sized_type, system.address);
function to_us is new
unchecked_conversion(system.address, address_sized_type);
function to_us is new
unchecked_conversion(duration, address_sized_type);
function to_us is new
unchecked_conversion(integer, address_sized_type);
function from_us is new
unchecked_conversion(address_sized_type, system.address);
function from_us is new
unchecked_conversion(address_sized_type, duration);
function from_us is new
unchecked_conversion(address_sized_type, integer);
Zero : constant address_sized_type := v_i_krn_trace.Zero;
----------------------------------------------------------------------------
-- Services needed by the Event_Log_Manager for the user and the
-- logging of runtime events by the kernel
type Kind_of_Event is
(No_Event, Header_Event, Runtime_Event, User_Defined_Event,
User_Defined_Integer_Event, Kernel_event,
Profile_Event);
-- Event Logging Operations
type User_Events is
(start_of_sequence,
start_process, -- Application initiates a process
end_process, -- Task completes a process
start_buffer_flush, -- Automatic, when full or at user request
end_buffer_flush,
process_base_time, -- Process established base time
event1, event1a,
event2, event2a,
event3, event3a,
event4, event4a,
event5, event5a,
event6, event6a,
event7, event7a,
event8, event8a,
event9, event9a,
event10, event10a,
no_event
);
type runtime_events is
(task_creation_begin,
task_creation_end,
simple_entry_call_req,
simple_entry_call_end,
timed_entry_call_req,
timed_entry_call_end,
timed_entry_call_timeout,
cond_entry_call_req,
cond_entry_call_end,
simple_accept_req,
simple_accept_end,
select_req,
select_else_req,
select_delay_req,
select_terminate_req,
select_end,
select_else_end,
select_delay_end,
select_terminate_end,
delay_req,
delay_expired,
continue_from_delay,
delay_until_req,
delay_until_expired,
continue_from_delay_until,
rte_exception,
raise_req,
exception_handler,
task_begin_req,
task_begin_begin,
task_terminate_req,
task_terminate,
task_abort_req,
task_abort,
task_semaphore_wait,
task_semaphore_wait_complete,
task_semaphore_wait_timeout,
task_semaphore_signal,
memory_allocate,
memory_deallocate,
-- Non-threaded run-time scheduling events
switch_to,
switch_to_idle_task,
switch_to_rendezvous_in_called,
-- Threaded run-time scheduling events
kernel_signal,
kernel_wait,
kernel_wait_complete,
kernel_signal_wait,
kernel_signal_wait_complete,
kernel_timed_wait,
kernel_timed_wait_complete,
kernel_timed_wait_timeout,
interrupt_entry,
interrupt_exit,
set_priority,
reevaluate_priority,
ceiling_set_priority,
cache_flush,
-- Passive tasks
passive_task_enter,
passive_task_leave,
passive_task_cond_enter,
passive_task_cond_fail,
passive_task_timed_enter,
passive_task_timed_timeout,
passive_ceiling_set_priority,
breakpoint, -- Inserted by a.db to explain large time gap
da_first, -- marker: FIRST DA event
-- Distributed Ada -- TYPE SIDE START/END
da_first_parent_sur, -- marker: FIRST parent-sur event
da_simple_entry_req, -- simple entry parent start
da_simple_entry_end, -- simple entry parent end
da_conditional_entry_req, -- cond entry parent start
da_conditional_entry_end, -- cond entry parent end
da_timed_entry_req, -- timed entry parent start
da_timed_entry_end, -- timed entry parent end
da_simple_entry_sur_req, -- simple entry sur start
da_simple_entry_sur_end, -- simple entry sur end
da_conditional_entry_sur_req,-- cond entry sur start
da_conditional_entry_sur_end,-- cond entry sur end
da_timed_entry_sur_req, -- timed entry sur start
da_timed_entry_sur_end, -- timed entry sur end
da_dt_read_req, -- read parent start
da_dt_read_end, -- read parent end
da_dt_write_req, -- write parent start
da_dt_write_end, -- write parent end
da_stub_read_req, -- read sur start
da_stub_read_end, -- read sur end
da_stub_write_req, -- write sur start
da_stub_write_end, -- write sur end
da_rem_subp_req, -- rpc parent start
da_rem_subp_end, -- rpc parent end
da_rem_subp_sur_req, -- rpc sur start
da_rem_subp_sur_end, -- rpc sur end
da_last_parent_sur, -- marker: LAST parent-sur event
-- non-parent-sur da events
da_local_new_req,
da_global_free_req,
da_local_free_req,
da_station_info,
da_task_activated_as_sur,
da_last -- marker: LAST DA event
);
type profile_events is (
calls,
returns,
basic_block,
exceptions,
interrupts,
cache_flushes,
operand_changed_address,
operand_changed_value,
program_generated_value
);
type runtime_enables is array(Runtime_Events) of boolean;
LOG_STRING_SIZE : constant integer :=
address_sized_type'size*4/character'size;
subtype Log_string is string(1..LOG_STRING_SIZE);
--
-- Raw event used in log routine
type event is record
logged_event : kind_of_event;
node : integer;
task_seqnum : integer;
time_stamp : microseconds;
arg1 : address_sized_type;
arg2 : address_sized_type;
arg3 : address_sized_type;
arg4 : address_sized_type;
end record;
event_size : constant integer := event'size;
-- The use of variant records leads to problems when programs that do not
-- explicitly with v_i_trace are linked with an instrumented run-time.
-- These are the variants
type header_event_record is record
logged_event : kind_of_event;
priority : byte;
node : integer;
task_seqnum : integer;
time_stamp : microseconds;
task_Name : address_sized_type;
phase : address_sized_type;
period : address_sized_type;
execution_time: microseconds;
end record;
-- On some systems, duration is 64 bits. Phase and period are converted.
--for header_event_record'size use event_size;
function to_event is new unchecked_conversion(header_event_record, event);
function to_header_event is new unchecked_conversion(event,
header_event_record);
type runtime_event_record is record
logged_event : kind_of_event;
rts_event : runtime_events;
node : integer;
task_seqnum : integer;
time_stamp : microseconds;
arg1 : address_sized_type;
arg2 : address_sized_type;
arg3 : address_sized_type;
arg4 : address_sized_type;
end record;
--for runtime_event_record'size use event_size;
function to_event is new unchecked_conversion(runtime_event_record, event);
function to_runtime_event is new unchecked_conversion(event,
runtime_event_record);
type kernel_event_record is record
logged_event : kind_of_event;
krn_event : byte;
node : integer;
task_seqnum : integer;
time_stamp : microseconds;
arg1 : address_sized_type;
arg2 : address_sized_type;
arg3 : address_sized_type;
arg4 : address_sized_type;
end record;
--for kernel_event_record'size use event_size;
function to_event is new unchecked_conversion(kernel_event_record, event);
function to_kernel_event is new unchecked_conversion(event,
kernel_event_record);
type user_event_record is record
logged_event : kind_of_event;
user_event : user_events;
node : integer;
task_seqnum : integer;
time_stamp : microseconds;
comment : log_string;
end record;
--for user_event_record'size use event_size;
function to_event is new unchecked_conversion(user_event_record, event);
function to_user_event is new unchecked_conversion(event,
user_event_record);
type user_int_event_record is record
logged_event : kind_of_event;
user_event : user_events;
node : integer;
task_seqnum : integer;
time_stamp : microseconds;
p1 : address_sized_type;
p2 : address_sized_type;
p3 : address_sized_type;
p4 : address_sized_type;
end record;
--for user_int_event_record'size use event_size;
function to_event is new
unchecked_conversion(user_int_event_record, event);
function to_user_int_event is new
unchecked_conversion(event, user_int_event_record);
type profile_event_record is record
logged_event : kind_of_event;
prof_event : profile_events;
node : integer;
task_seqnum : integer;
time_stamp : microseconds;
location : address_sized_type;
word1 : address_sized_type;
word2 : address_sized_type;
word3 : address_sized_type;
end record;
--for profile_event_record'size use event_size;
function to_event is new
unchecked_conversion(profile_event_record, event);
function to_profile_event is new
unchecked_conversion(event, profile_event_record);
event_record_size : integer;
pragma interface_name(event_record_size,
"__V_I_TRACE_EVENT_RECORD_SIZE");
--
auto_trace : boolean;
pragma interface_name(auto_trace, "__V_I_TRACE_AUTO_TRACE");
--
Runtime_log : Runtime_enables;
pragma interface_name(Runtime_log, "__V_I_TRACE_RUNTIME_LOG");
Runtime_setup : Runtime_enables;
-- Deliberately using constrained array. Allows use of
-- unchecked_conversion from address to pointer and back. (Vads
-- specific)
pragma warnings(off);
type event_buffer_t is array (positive) of v_i_trace.event;
type a_event_buffer_t is access event_buffer_t;
pragma warnings(on);
event_buffer: a_event_buffer_t;
event_buffer_size : integer; -- 4096 Default unless overridden by user
event_buffer_index : integer;
pragma interface_name(event_buffer, "__V_I_TRACE_EVENT_BUFFER");
pragma interface_name(event_buffer_size,
"__V_I_TRACE_EVENT_BUFFER_SIZE");
pragma interface_name(event_buffer_index,
"__V_I_TRACE_EVENT_BUFFER_INDEX");
wrap_around : boolean;
log_overflowed : boolean;
disable_locking : boolean;
hardware_logging : boolean;
pragma interface_name(wrap_around, "__V_I_TRACE_WRAP_AROUND");
pragma interface_name(log_overflowed, "__V_I_TRACE_LOG_OVERFLOWED");
pragma interface_name(disable_locking, "__V_I_TRACE_DISABLE_LOCKING");
pragma interface_name(hardware_logging,"__V_I_TRACE_HARDWARE_LOGGING");
-- We can't call system services in preemption callout.
-- Unless the user supplies a get_time callout, we will log using the
-- last event's time. Only a problem in MP Ada.
last_secs : microseconds;
pragma interface_name(last_secs, "__V_I_TRACE_LAST_SECS");
type a_boolean is access boolean;
type a_integer is access integer;
type a_uinteger is access unsigned_types.unsigned_integer;
type trace_configuration_t is record
-- User configurable
Runtime_log : Runtime_enables;
event_buffer_size : integer; -- number of records
event_buffer : a_event_buffer_t; -- null is don't care
wrap_around : boolean;
hardware_logging : boolean;
disable_locking : boolean; -- single processor,
-- not logging interrupts
nearly_full_callout : system.address; -- no_addr is don't care
nearly_full_index : integer;
get_time_callout : system.address; -- used in user code and
-- task services
krn_get_time_callout : system.address; -- callable from kernel
log_callout : system.address;
Krn_log_enables : v_i_krn_trace.kernel_enables;
-- Should not be modified by user
-- Communication with kernel on cross systems
event_buffer_index : a_integer;
log_overflowed : a_boolean;
init_logging_address : system.address;
hardware_logging_1 : a_uinteger;
hardware_logging_2 : a_uinteger;
hardware_logging_3 : a_uinteger;
hardware_logging_4 : a_uinteger;
end record;
type a_trace_configuration_t is access trace_configuration_t;
type arg_type is (arg_tsn, arg_tsa, arg_ra, arg_pc, arg_time,
arg_entry, arg_priority, arg_exid,
arg_sema, arg_boolean, arg_integer,
arg_address, arg_size,
arg_intid,
arg_status, arg_cause, -- MIPS registers
arg_station, arg_seq, -- for DA
arg_id, arg_value,
arg_null);
type arg_descriptor is record
arg1_type : arg_type;
arg2_type : arg_type;
arg3_type : arg_type;
arg4_type : arg_type;
end record;
arg_descriptors: array(Runtime_Events) of arg_descriptor :=
(task_creation_begin => (arg_priority,arg_ra,arg_null,arg_null),
task_creation_end => (arg_tsn,arg_ra,arg_tsa, arg_null),
simple_entry_call_req => (arg_tsn,arg_entry,arg_ra, arg_null),
simple_entry_call_end => (arg_tsn,arg_tsa, arg_null,arg_null),
timed_entry_call_req => (arg_tsn, arg_entry, arg_ra,arg_null),
timed_entry_call_end => (arg_tsn,arg_boolean,arg_tsa ,arg_null),
timed_entry_call_timeout => (arg_null, arg_null,arg_null,arg_null),
cond_entry_call_req => (arg_tsn, arg_entry, arg_ra,arg_null),
cond_entry_call_end => (arg_tsn,arg_boolean,arg_tsa, arg_null),
simple_accept_req => (arg_entry, arg_ra,arg_null,arg_null),
simple_accept_end => (arg_ra,arg_tsa, arg_null,arg_null),
select_req => (arg_ra, arg_null,arg_null,arg_null),
select_else_req => (arg_ra, arg_null,arg_null,arg_null),
select_delay_req => (arg_ra, arg_null,arg_null,arg_null),
select_terminate_req => (arg_ra, arg_null,arg_null,arg_null),
select_end => (arg_entry, arg_null,arg_null,arg_null),
select_else_end => (arg_entry, arg_null,arg_null,arg_null),
select_delay_end => (arg_entry, arg_null,arg_null,arg_null),
select_terminate_end => (arg_entry, arg_null,arg_null,arg_null),
delay_req => (arg_ra, arg_time,arg_null,arg_null),
delay_expired => (arg_null,arg_null,arg_null,arg_null),
continue_from_delay => (arg_tsa, arg_null,arg_null,arg_null),
delay_until_req => (arg_ra, arg_time,arg_null,arg_null),
delay_until_expired => (arg_null,arg_null,arg_null,arg_null),
continue_from_delay_until => (arg_tsa, arg_null,arg_null,arg_null),
rte_exception => (arg_exid,arg_ra, arg_null,arg_null),
raise_req => (arg_exid,arg_ra, arg_null,arg_null),
exception_handler => (arg_exid,arg_pc, arg_null,arg_null),
task_begin_req => (arg_tsn,arg_ra, arg_null,arg_null),
task_begin_begin => (arg_tsn,arg_tsn, arg_null,arg_null),
task_terminate_req => (arg_tsn,arg_ra, arg_null,arg_null),
task_terminate => (arg_null, arg_null,arg_null,arg_null),
task_abort_req => (arg_tsn,arg_ra, arg_null,arg_null),
task_abort => (arg_tsn, arg_null,arg_null,arg_null),
task_semaphore_wait => (arg_sema,arg_time, arg_null,arg_null),
task_semaphore_wait_complete=> (arg_sema, arg_null,arg_null,arg_null),
task_semaphore_wait_timeout => (arg_sema, arg_null,arg_null,arg_null),
task_semaphore_signal => (arg_sema, arg_null,arg_null,arg_null),
memory_allocate => (arg_address,arg_size,arg_ra, arg_null),
memory_deallocate => (arg_address,arg_ra, arg_null,arg_null),
switch_to => (arg_tsn, arg_null,arg_null,arg_null),
switch_to_idle_task => (arg_null,arg_null,arg_null,arg_null),
switch_to_rendezvous_in_called => (arg_tsn,arg_tsa ,arg_null,arg_null),
kernel_signal => (arg_tsn, arg_null,arg_null,arg_null),
kernel_wait => (arg_tsn, arg_null,arg_null,arg_null),
kernel_wait_complete => (arg_tsn, arg_null,arg_null,arg_null),
kernel_signal_wait => (arg_tsn, arg_null,arg_null,arg_null),
kernel_signal_wait_complete => (arg_tsn, arg_null,arg_null,arg_null),
kernel_timed_wait => (arg_tsn, arg_time,arg_null,arg_null),
kernel_timed_wait_complete => (arg_tsn, arg_null,arg_null,arg_null),
kernel_timed_wait_timeout => (arg_tsn, arg_null,arg_null,arg_null),
interrupt_entry => (arg_intid,arg_pc,arg_status,arg_cause),
interrupt_exit => (arg_intid,arg_pc,arg_null,arg_null),
set_priority => (arg_tsn,arg_priority,arg_null,arg_null),
reevaluate_priority => (arg_tsn,arg_priority,arg_null,arg_null),
ceiling_set_priority => (arg_tsn,arg_priority,arg_null,arg_null),
cache_flush => (arg_ra, arg_address, arg_size, arg_integer),
passive_task_enter => (arg_ra, arg_null, arg_null, arg_null),
passive_task_leave => (arg_ra, arg_null, arg_null, arg_null),
passive_task_cond_enter => (arg_ra, arg_null, arg_null, arg_null),
passive_task_cond_fail => (arg_ra, arg_null, arg_null, arg_null),
passive_task_timed_enter => (arg_ra, arg_null, arg_null, arg_null),
passive_task_timed_timeout => (arg_ra, arg_null, arg_null, arg_null),
passive_ceiling_set_priority => (arg_priority,arg_ra,arg_null,arg_null),
breakpoint => (arg_null, arg_null,arg_null,arg_null),
-- Distributed Ada
-- NOTE: Any da events which have components logged both on the
-- parent and the surrogate should be added between
-- da_first_parent_sur and da_last_parent_sur.
-- They should have an arg_station as their FIRST arg. On the
-- parent, this should be the surrogate's station number and
-- visa versa.
da_first =>(arg_null, arg_null,arg_null,arg_null),
-- parent-surrogate paired da events
da_first_parent_sur =>(arg_null, arg_null,arg_null,arg_null),
da_simple_entry_req =>(arg_station, arg_seq, arg_pc, arg_entry),
da_simple_entry_end =>(arg_station, arg_seq, arg_pc, arg_entry),
da_conditional_entry_req =>(arg_station, arg_seq, arg_pc, arg_entry),
da_conditional_entry_end =>(arg_station, arg_seq, arg_pc, arg_boolean),
da_timed_entry_req =>(arg_station, arg_seq, arg_pc, arg_entry),
da_timed_entry_end =>(arg_station, arg_seq, arg_pc, arg_boolean),
da_simple_entry_sur_req =>(arg_station, arg_seq, arg_tsn, arg_entry),
da_simple_entry_sur_end =>(arg_station, arg_seq, arg_tsn, arg_entry),
da_conditional_entry_sur_req =>
(arg_station, arg_seq, arg_tsn, arg_entry),
da_conditional_entry_sur_end =>
(arg_station, arg_seq, arg_tsn, arg_entry),
da_timed_entry_sur_req =>(arg_station, arg_seq, arg_tsn, arg_entry),
da_timed_entry_sur_end =>(arg_station, arg_seq, arg_tsn, arg_entry),
da_dt_read_req =>(arg_station, arg_seq, arg_pc, arg_size),
da_dt_read_end =>(arg_station, arg_seq, arg_pc, arg_size),
da_dt_write_req =>(arg_station, arg_seq, arg_pc, arg_size),
da_dt_write_end =>(arg_station, arg_seq, arg_pc, arg_size),
da_stub_read_req =>(arg_station, arg_seq, arg_address,arg_null),
da_stub_read_end =>(arg_station, arg_seq, arg_address,arg_null),
da_stub_write_req =>(arg_station, arg_seq, arg_address,arg_null),
da_stub_write_end =>(arg_station, arg_seq, arg_address,arg_null),
da_rem_subp_req =>(arg_station, arg_seq, arg_pc, arg_null),
da_rem_subp_end =>(arg_station, arg_seq, arg_pc, arg_null),
da_rem_subp_sur_req =>(arg_station, arg_seq, arg_pc, arg_null),
da_rem_subp_sur_end =>(arg_station, arg_seq, arg_pc, arg_null),
da_last_parent_sur =>(arg_null, arg_null,arg_null, arg_null),
-- non parent-surrogate paired da events
da_local_new_req =>(arg_pc, arg_size, arg_null, arg_null),
da_global_free_req =>(arg_station, arg_pc, arg_tsn, arg_null),
da_local_free_req =>(arg_station, arg_pc, arg_tsn, arg_null),
da_station_info =>(arg_station, arg_value, arg_value, arg_value),
da_task_activated_as_sur =>(arg_tsn, arg_boolean, arg_null, arg_null),
da_last =>(arg_null, arg_null,arg_null, arg_null)
);
profile_arg_descriptors: array(Profile_Events) of arg_descriptor :=
(calls => (arg_ra, arg_null, arg_null, arg_null),
returns => (arg_ra, arg_null, arg_null, arg_null),
basic_block => (arg_ra, arg_null, arg_null, arg_null),
exceptions => (arg_ra, arg_null, arg_null, arg_null),
interrupts => (arg_ra, arg_null, arg_null, arg_null),
cache_flushes => (arg_ra, arg_null, arg_null, arg_null),
operand_changed_address => (arg_ra, arg_id, arg_address, arg_null),
operand_changed_value => (arg_ra, arg_id, arg_value, arg_value),
program_generated_value => (arg_ra, arg_null, arg_null, arg_null));
procedure rte_log(kind : runtime_events;
p1 : address_sized_type := Zero;
p2 : address_sized_type := Zero;
p3 : address_sized_type := Zero;
p4 : address_sized_type := Zero);
pragma interface(Ada, rte_log);
pragma interface_name(rte_log, "__TS_DEBUG_RTE_LOG");
procedure user_log(kind : user_events;
comment: v_i_trace.log_string);
pragma interface(Ada, user_log);
pragma interface_name(user_log, "__TS_DEBUG_USER_LOG");
procedure user_log_int(kind : user_events;
p1 : address_sized_type := Zero;
p2 : address_sized_type := Zero;
p3 : address_sized_type := Zero;
p4 : address_sized_type := Zero);
pragma interface(Ada, user_log_int);
pragma interface_name(user_log_int, "__TS_DEBUG_USER_LOG_INT");
procedure header_log(event_rec: in out header_event_record);
pragma interface(Ada, header_log);
pragma interface_name(header_log, "__TS_DEBUG_HEADER_LOG");
------------------------------------------------------------------
procedure log_call;
pragma interface(Ada, log_call);
pragma interface_name(log_call, "__TRACE_LOG_CALL");
procedure log_return;
pragma interface(Ada, log_return);
pragma interface_name(log_return, "__TRACE_LOG_RETURN");
procedure log_basic_block;
pragma interface(Ada, log_basic_block);
pragma interface_name(log_basic_block, "__TRACE_LOG_BLOCK");
procedure log_variable_word(id: integer;
value: integer);
pragma interface(Ada, log_variable_word);
pragma interface_name(log_variable_word, "__TRACE_LOG_VARIABLE_WORD");
procedure log_variable(id : integer;
location : integer;
bit_size : integer);
pragma interface(Ada, log_variable);
pragma interface_name(log_variable, "__TRACE_LOG_VARIABLE");
------------------------------------------------------------------
-- DA related sub-routines
function seq_num_for_sur_req(station: integer) return integer;
pragma interface(Ada,seq_num_for_sur_req);
pragma interface_name(seq_num_for_sur_req, "__SEQ_NUM_FOR_SUR_REQ");
function seq_num_for_parent_req(station: integer) return integer;
pragma interface(Ada,seq_num_for_parent_req);
pragma interface_name(seq_num_for_parent_req, "__SEQ_NUM_FOR_PARENT_REQ");
------------------------------------------------------------------
procedure init_logging(configuration: a_trace_configuration_t);
pragma interface(Ada, init_logging);
pragma interface_name(init_logging, "__TS_DEBUG_INIT_LOGGING");
end v_i_trace