Tutorials:SynchroTrace Sigil IISWC 2016 - Revision history

Scott at 21:29, 22 September 2016

2016-09-22T21:29:10Z

← Older revision		Revision as of 17:29, 22 September 2016
Line 43:		Line 43:
	## Replaying traces		## Replaying traces
	## Results from paper: Speedy, yet accurate simulation		## Results from paper: Speedy, yet accurate simulation
	~~# Guest Speaker (''45 minutes'')~~
	# Hands-on Sigil		# Hands-on Sigil
	## Downloading and installing Sigil		## Downloading and installing Sigil

Mdl45 at 19:22, 29 August 2016

2016-08-29T19:22:23Z

← Older revision		Revision as of 15:22, 29 August 2016
Line 16:		Line 16:
	===Topic Outline===		===Topic Outline===

	In this tutorial, we discuss ~~Sigil;~~ a workload profiling toolset that allows architects to explore and investigate sources of performance bottlenecks in current and future systems. Sigil captures platform-independent behavior from workloads which can be used to assist HW/SW partitioning problems and to assist trace-~~based~~ simulation ~~of multi-threaded workloads on CMPs~~. ~~This~~ tutorial ~~also presents SynchroTrace, a simulation~~ framework ~~built on top of Sigil to perform~~ trace~~-based simulation~~.		In this tutorial, we discuss the SynchroTrace simulation framework -- a fast trace-driven simulation tool for large design space exploration. The tutorial discusses the two major components of the framework: the trace generation tool, Sigil2, and the architectural simulator, SynchroTraceGen.

	===Synopsis===		===Synopsis===

	~~<!--~~		Current architectures trend towards more cores, including ASIC IPs, general purpose CPUs, and GPUs. Understanding how these cores communicate and interact with each other will be ''critical'' to extracting the most performance and efficiency out of future architectures. The Drexel VLSI & Architecture Lab has developed a set of tools are required to enable this by extracting information on how cores communicate. Our proposed solutions are [http://dpac.ece.drexel.edu/current-research-projects/sigil/ Sigil], a tool to capture platform-independent communication, and [[SynchroTrace]], a framework which extends Sigil and adds mechanisms to enable simulation of future systems.
	Current architectures trend towards more cores, including ASIC IPs, general purpose CPUs, and GPUs. Understanding how these cores communicate and interact with each other will be ''critical'' to extracting the most performance and efficiency out of future architectures. ~~To enable this understanding,~~ a set of tools are required to ~~extract~~ information on how cores communicate. Our proposed solutions are [http://dpac.ece.drexel.edu/current-research-projects/sigil/ Sigil], a tool to capture platform-independent communication, and [[SynchroTrace]], a framework which extends Sigil and adds mechanisms to enable simulation of future systems.

	In this tutorial we discuss the implementation ~~of our tools to promote confidence in the utility~~ of our tools and we also demonstrate the ~~running of the tools to inform the community of their reliability and applicability~~.		In this tutorial we discuss the implementation of our tools and also demonstrate the example use-cases.

	The [http://dpac.ece.drexel.edu/current-research-projects/sigil/ Sigil] tool is written to capture and classify computation operations, communication edges between functions/threads, and intercept synchronization operations in threads; Sigil data give insight into the true costs that exist within a workload. This enables data-driven design decisions and analysis in designing future systems. We discuss how a Shadow memory implementation of Sigil can capture platform-independent data and also briefly discuss how the data can be applied to perform HW/SW partitioning.		The [http://dpac.ece.drexel.edu/current-research-projects/sigil/ Sigil] tool is written to capture and classify computation operations, communication edges between functions/threads, and intercept synchronization operations in threads; Sigil data give insight into the true costs that exist within a workload. This enables data-driven design decisions and analysis in designing future systems. We discuss how a Shadow memory implementation of Sigil can capture platform-independent data and also briefly discuss how the data can be applied to perform HW/SW partitioning.

	The [[SynchroTrace]] simulation framework utilizes Sigil's platform-independent traces to quickly explore a design space. Synchronization aware traces and replay of those traces, instead of single-threaded deterministic traces, enables accurate simulation of communication bound architectures. With the addition of fast trace-driven simulation, SynchroTrace quickly iterates over a large design space and assists with design decisions such as NoC design and memory models. We discuss the intercept mechanism by which the Sigil tool is able to capture synchronization constructs. We will also discuss and demonstrate SynchroTrace's trace capture and simulation mechanisms in detail.		The [[SynchroTrace]] simulation framework utilizes Sigil's platform-independent traces to quickly explore a design space. Synchronization aware traces and replay of those traces, instead of single-threaded deterministic traces, enables accurate simulation of communication bound architectures. With the addition of fast trace-driven simulation, SynchroTrace quickly iterates over a large design space and assists with design decisions such as NoC design and memory models. We discuss the intercept mechanism by which the Sigil tool is able to capture synchronization constructs. We will also discuss and demonstrate SynchroTrace's trace capture and simulation mechanisms in detail.
	~~-->~~

	===Agenda===		===Agenda===

	~~<!--~~
	# Overview and welcome		# Overview and welcome
	# Sigil; a Communication-aware workload profiling tool (''45 minutes'')		# Sigil; a Communication-aware workload profiling tool (''45 minutes'')
	## ~~Capture implementation~~		## Trace capture
	## Running Sigil		## Running Sigil
	## HW/SW partitioning ~~process~~		## HW/SW partitioning example
	## Example on running post-processing		## Example on running post-processing
	# SynchroTrace (''45 minutes'')		# SynchroTrace (''45 minutes'')
	## ~~Capturing synchronization in multi-threading~~		## SynchroTraceGen: a Sigil extension
	## Sigil~~'s intercept mechanism~~		## SynchroTraceGen trace format
	## ~~Sigil's Trace~~ format
	## Generating traces		## Generating traces
	## SynchroTrace Replay		## SynchroTrace Replay
Line 56:		Line 52:
	## Running Sigil and interpreting trace generation		## Running Sigil and interpreting trace generation
	## Running Replay and understanding Replay output		## Running Replay and understanding Replay output
	~~-->~~

	===Related Media and Links===		===Related Media and Links===

Mdl45: comment out sections from previous tutorial

2016-08-28T18:38:48Z

comment out sections from previous tutorial

← Older revision		Revision as of 14:38, 28 August 2016
Line 10:		Line 10:
	[[Baris Taskin\| Dr. Baris Taskin]], ''Drexel University''		[[Baris Taskin\| Dr. Baris Taskin]], ''Drexel University''

	[[~~Paco~~ Sangaiah]], ''Drexel University''		[[Karthik Sangaiah]], ''Drexel University''

	[[Michael Lui]], ''Drexel University''		[[Michael Lui]], ''Drexel University''
Line 20:		Line 20:
	===Synopsis===		===Synopsis===

			<!--
	Current architectures trend towards more cores, including ASIC IPs, general purpose CPUs, and GPUs. Understanding how these cores communicate and interact with each other will be ''critical'' to extracting the most performance and efficiency out of future architectures. To enable this understanding, a set of tools are required to extract information on how cores communicate. Our proposed solutions are [http://dpac.ece.drexel.edu/current-research-projects/sigil/ Sigil], a tool to capture platform-independent communication, and [[SynchroTrace]], a framework which extends Sigil and adds mechanisms to enable simulation of future systems.		Current architectures trend towards more cores, including ASIC IPs, general purpose CPUs, and GPUs. Understanding how these cores communicate and interact with each other will be ''critical'' to extracting the most performance and efficiency out of future architectures. To enable this understanding, a set of tools are required to extract information on how cores communicate. Our proposed solutions are [http://dpac.ece.drexel.edu/current-research-projects/sigil/ Sigil], a tool to capture platform-independent communication, and [[SynchroTrace]], a framework which extends Sigil and adds mechanisms to enable simulation of future systems.

Line 27:		Line 28:

	The [[SynchroTrace]] simulation framework utilizes Sigil's platform-independent traces to quickly explore a design space. Synchronization aware traces and replay of those traces, instead of single-threaded deterministic traces, enables accurate simulation of communication bound architectures. With the addition of fast trace-driven simulation, SynchroTrace quickly iterates over a large design space and assists with design decisions such as NoC design and memory models. We discuss the intercept mechanism by which the Sigil tool is able to capture synchronization constructs. We will also discuss and demonstrate SynchroTrace's trace capture and simulation mechanisms in detail.		The [[SynchroTrace]] simulation framework utilizes Sigil's platform-independent traces to quickly explore a design space. Synchronization aware traces and replay of those traces, instead of single-threaded deterministic traces, enables accurate simulation of communication bound architectures. With the addition of fast trace-driven simulation, SynchroTrace quickly iterates over a large design space and assists with design decisions such as NoC design and memory models. We discuss the intercept mechanism by which the Sigil tool is able to capture synchronization constructs. We will also discuss and demonstrate SynchroTrace's trace capture and simulation mechanisms in detail.
			-->

	===Agenda===		===Agenda===

			<!--
	# Overview and welcome		# Overview and welcome
	# Sigil; a Communication-aware workload profiling tool (''45 minutes'')		# Sigil; a Communication-aware workload profiling tool (''45 minutes'')
Line 54:		Line 56:
	## Running Sigil and interpreting trace generation		## Running Sigil and interpreting trace generation
	## Running Replay and understanding Replay output		## Running Replay and understanding Replay output
			-->

	===Related Media and Links===		===Related Media and Links===
	[https://github.com/dpac-vlsi SynchroTrace and Sigil Download]		[https://github.com/dpac-vlsi SynchroTrace and Sigil Download]

			<!--
	[[media:Synchrotrace_tutorial.pdf\|SynchroTrace Tutorial Presentation]]		[[media:Synchrotrace_tutorial.pdf\|SynchroTrace Tutorial Presentation]]

	[[media:Sigil_Tutorial_Slides_ICCD2015.pdf‎\|Sigil Tutorial Presentation]]		[[media:Sigil_Tutorial_Slides_ICCD2015.pdf‎\|Sigil Tutorial Presentation]]
			-->

Mdl45 at 22:01, 26 August 2016

2016-08-26T22:01:14Z

← Older revision		Revision as of 18:01, 26 August 2016
Line 1:		Line 1:
	= IEEE International Symposium on Workload Characterization (~~ICCD~~), 2016 =		= IEEE International Symposium on Workload Characterization (IISWC), 2016 =
	'''September 25-27, Providence, Rhode Island, USA'''		'''September 25-27, Providence, Rhode Island, USA'''

Mdl45: Created page with '= IEEE International Symposium on Workload Characterization (ICCD), 2016 = '''September 25-27, Providence, Rhode Island, USA''' ==Sigil2 and SynchroTrace: Flexible Workload Pro...'

2016-08-26T17:00:27Z

Created page with '= IEEE International Symposium on Workload Characterization (ICCD), 2016 = '''September 25-27, Providence, Rhode Island, USA''' ==Sigil2 and SynchroTrace: Flexible Workload Pro...'

New page

= IEEE International Symposium on Workload Characterization (ICCD), 2016 =
'''September 25-27, Providence, Rhode Island, USA'''

==Sigil2 and SynchroTrace: Flexible Workload Profiling and Fast Memory-NoC Simulation==

===Organizers===
[http://engineering.tufts.edu/ece/people/hempstead.htm Dr. Mark Hempstead], ''Tufts University''

[[Baris Taskin| Dr. Baris Taskin]], ''Drexel University''

[[Paco Sangaiah]], ''Drexel University''

[[Michael Lui]], ''Drexel University''

===Topic Outline===

In this tutorial, we discuss Sigil; a workload profiling toolset that allows architects to explore and investigate sources of performance bottlenecks in current and future systems. Sigil captures platform-independent behavior from workloads which can be used to assist HW/SW partitioning problems and to assist trace-based simulation of multi-threaded workloads on CMPs. This tutorial also presents SynchroTrace, a simulation framework built on top of Sigil to perform trace-based simulation.

===Synopsis===

Current architectures trend towards more cores, including ASIC IPs, general purpose CPUs, and GPUs. Understanding how these cores communicate and interact with each other will be ''critical'' to extracting the most performance and efficiency out of future architectures. To enable this understanding, a set of tools are required to extract information on how cores communicate. Our proposed solutions are [http://dpac.ece.drexel.edu/current-research-projects/sigil/ Sigil], a tool to capture platform-independent communication, and [[SynchroTrace]], a framework which extends Sigil and adds mechanisms to enable simulation of future systems.

In this tutorial we discuss the implementation of our tools to promote confidence in the utility of our tools and we also demonstrate the running of the tools to inform the community of their reliability and applicability.

The [http://dpac.ece.drexel.edu/current-research-projects/sigil/ Sigil] tool is written to capture and classify computation operations, communication edges between functions/threads, and intercept synchronization operations in threads; Sigil data give insight into the true costs that exist within a workload. This enables data-driven design decisions and analysis in designing future systems. We discuss how a Shadow memory implementation of Sigil can capture platform-independent data and also briefly discuss how the data can be applied to perform HW/SW partitioning.

The [[SynchroTrace]] simulation framework utilizes Sigil's platform-independent traces to quickly explore a design space. Synchronization aware traces and replay of those traces, instead of single-threaded deterministic traces, enables accurate simulation of communication bound architectures. With the addition of fast trace-driven simulation, SynchroTrace quickly iterates over a large design space and assists with design decisions such as NoC design and memory models. We discuss the intercept mechanism by which the Sigil tool is able to capture synchronization constructs. We will also discuss and demonstrate SynchroTrace's trace capture and simulation mechanisms in detail.

===Agenda===

# Overview and welcome
# Sigil; a Communication-aware workload profiling tool (''45 minutes'')
## Capture implementation
## Running Sigil
## HW/SW partitioning process
## Example on running post-processing
# SynchroTrace (''45 minutes'')
## Capturing synchronization in multi-threading
## Sigil's intercept mechanism
## Sigil's Trace format
## Generating traces
## SynchroTrace Replay
## Replaying traces
## Results from paper: Speedy, yet accurate simulation
# Guest Speaker (''45 minutes'')
# Hands-on Sigil
## Downloading and installing Sigil
## Running Sigil and interpreting output
## Running post-processing and parsing
# Hands-on SynchroTrace
## Downloading and installing SynchroTrace
## Running Sigil and interpreting trace generation
## Running Replay and understanding Replay output

===Related Media and Links===
[https://github.com/dpac-vlsi SynchroTrace and Sigil Download]

[[media:Synchrotrace_tutorial.pdf|SynchroTrace Tutorial Presentation]]

[[media:Sigil_Tutorial_Slides_ICCD2015.pdf‎|Sigil Tutorial Presentation]]