Specification of Patterns in MPI Traces

1
Specification of Patternsin MPI Traces

• Designed by Felix Wolf
• f.wolf_at_fz-juelich.deResearch Centre Jülich

2
Why Patterns?

• More detailed information on
• when
• where
• why
• Profiling high communication / idle times
• Tracing late sender, late receiver,
  out-of-order messages, ...
• Event trace tools exist ? why ignore them?

3
EARL (Event Analysis and Recognition Language)

• high-level trace analysis language
• embedded in TCL, Perl, and Python scripting
  languages
• generic event trace analysis tool
• supports ALOG, CLOG, and Vampir trace formats
• currently supports message passing
• predefined event types enter/exit region,
  send/receive message
• provides region stacks and message queue
• in the future support for OpenMP and
  hierarchical prog. models
• Features
• event trace objects methods for trace handling,
  event and state access, iterator control, and
  general information access
• statistic objects providing computation of
  extreme values and quartiles for large number of
  values

4
EARL Example Messages out of Order
5
EARL Example (TCL)
!/usr/bin/tclsh8.0 package require earl
EventTrace e -file \ lindex argv
0 while e next e event curr if
curr(type) "recv" foreach send e
queue curr(src) curr(loc) if send lt
curr(sendptr) puts -nonewline
"Received message in wrong order" puts "
at loc curr(loc) at curr(time) sec."
rename e
6
EARL Example (Python)
!/usr/bin/python from earl import from sys
import e EventTrace(fileargv1) while
e.next() curr e.event() if curr"type"
"recv" for send in e.queue(curr"src",
curr"loc") if (send lt
curr"sendptr") print "Received
message in wrong order", print " at loc
", curr"loc", print " at time ",
curr"time" del e
7
EARL Example (Perl)
!/usr/bin/perl use earl e new EventTrace
(file gt ARGV0) while (e-gtnext())
curr e-gtevent() if (curr"type"
eq "recv") foreach (_at_e-gtqueue(curr"src"
, curr"loc")) if (_ lt
curr"sendptr") print("Received
message in wrong order") print( at loc
",curr"loc") print(" at
",curr"time"," sec.\n")
e undef
8
Pattern Specification Basic Concepts

• Implementation-driven specification
• Concepts
• Basic events
• timestamp
• location (process or thread)
• additional attributes
• Trace
• event sequence ordered according to timestamps
• iltk ? ei.loc ek.loc ? ei.time lt ek.time
• State
• summarizes ongoing activities
• represented by a set of events (start events of
  ongoing activities)

9
Basic Concepts (cont.)

• State (cont.)
• recursive definition
• depends only on history
• S0?
• ? ei?trace SiF(Si-1,ei)
• F adds event if start event of activity
• F eliminates corresponding start event if exit
  event
• Extending basic event types
• additional attributes linking related events
• linking events included in state (efficient
  implementation)
• definition of additional attribute a
  ei.afa(ei,Si-1)

10
Example Extending Basic Event Types
11
Basic Concepts (cont.)

• Compound event (instantiated pattern)
• set of events called constituents
• constituents are combined into roles
• set of roles is a partition of the compound event
• root
• unique role
• includes a single event called root event

12
Basic Concepts (cont.)

• Compound event types (patterns) are defined via
• predicate root Events ? True/False
• for each role except root
• function determining the events belonging to that
  role
• the dependence graph is acyclic
• Instantiation of a pattern p for an event e
  depends on
• rootp(e) True
• evaluation of role functions do not fail

13
Late Sender Pattern
14
Late Sender Pattern (cont.)
15
Remarks

• General
• designed for efficient implementation
• integration of collective operations has to be
  investigated
• is backtracking in role instantiation needed?
• complexity of functions is unclear (are code
  fragments required?)
• Integration into ASL
• extending basic event event types is not required
• references can be replaced by defining functions
• state can be defined via a global function
• some extensions to function definitions might be
  required (case-based definitions)
• Felix defines it via a transition method of the
  event classes