Layout Test - Revision history

imported>Admin at 01:46, May 20, 2014

2014-05-20T01:46:07Z

← Older revision		Revision as of 01:46, May 20, 2014
Line 9:		Line 9:
	* [[#table3\|How will the runtime manage resources (compute, memory, power, bandwidth) for 100K sockets to meet a power, energy and performance objective?]]		* [[#table3\|How will the runtime manage resources (compute, memory, power, bandwidth) for 100K sockets to meet a power, energy and performance objective?]]
	* [[#table4\|How does the runtime software itself scale to 100K sockets? Specifically, how does it distribute, monitor and balance itself and how is it resilient to failures?]]		* [[#table4\|How does the runtime software itself scale to 100K sockets? Specifically, how does it distribute, monitor and balance itself and how is it resilient to failures?]]
	* [[#5\|What is the efficiency of the runtime? Specifically, how much impact does the runtime have on a) the total execution time of the application and b) resources taken from algorithmic computations? What are your plans to maximize efficiency? How will runtime overhead scale to 100K sockets?]]		* [[#table5\|What is the efficiency of the runtime? Specifically, how much impact does the runtime have on a) the total execution time of the application and b) resources taken from algorithmic computations? What are your plans to maximize efficiency? How will runtime overhead scale to 100K sockets?]]
	* [[#6\|Do you support isolation of the runtime code from the user code to avoid violations and contamination?]]		* [[#table6\|Do you support isolation of the runtime code from the user code to avoid violations and contamination?]]
	* [[#7\|What specific hardware features do you require for proper or efficient runtime operation (atomics, DMA, F/E bits, etc.)?]]		* [[#table7\|What specific hardware features do you require for proper or efficient runtime operation (atomics, DMA, F/E bits, etc.)?]]
	* [[#8\|What is your model for execution of multiple different programs (ie: a single mention would be doing more than one thing) in terms of division, isolation, containment and protection?]]		* [[#table8\|What is your model for execution of multiple different programs (ie: a single mention would be doing more than one thing) in terms of division, isolation, containment and protection?]]

	<div id="table1"></div>{{ProjectTable		<div id="table1"></div>{{ProjectTable
Line 94:		Line 94:
	}}		}}

	{{ProjectTable		<div id="table4"></div>{{ProjectTable

	\|question=How does the runtime software itself scale to 100K sockets? Specifically, how does it distribute, monitor and balance itself and how is it resilient to failures?		\|question=How does the runtime software itself scale to 100K sockets? Specifically, how does it distribute, monitor and balance itself and how is it resilient to failures?
Line 124:		Line 124:
	}}		}}

	{{ProjectTable		<div id="table5"></div>{{ProjectTable

	\|question=What is the efficiency of the runtime? Specifically, how much impact does the runtime have on a) the total execution time of the application and b) resources taken from algorithmic computations? What are your plans to maximize efficiency? How will runtime overhead scale to 100K sockets?		\|question=What is the efficiency of the runtime? Specifically, how much impact does the runtime have on a) the total execution time of the application and b) resources taken from algorithmic computations? What are your plans to maximize efficiency? How will runtime overhead scale to 100K sockets?
Line 154:		Line 154:
	}}		}}

	{{ProjectTable		<div id="table6"></div>{{ProjectTable

	\|question=Do you support isolation of the runtime code from the user code to avoid violations and contamination?		\|question=Do you support isolation of the runtime code from the user code to avoid violations and contamination?
Line 184:		Line 184:
	}}		}}

	{{ProjectTable		<div id="table7"></div>{{ProjectTable

	\|question=What specific hardware features do you require for proper or efficient runtime operation (atomics, DMA, F/E bits, etc.)?		\|question=What specific hardware features do you require for proper or efficient runtime operation (atomics, DMA, F/E bits, etc.)?
Line 214:		Line 214:
	}}		}}

	{{ProjectTable		<div id="table8"></div>{{ProjectTable

	\|question=What is your model for execution of multiple different programs (ie: a single mention would be doing more than one thing) in terms of division, isolation, containment and protection?		\|question=What is your model for execution of multiple different programs (ie: a single mention would be doing more than one thing) in terms of division, isolation, containment and protection?

imported>Admin at 01:43, May 20, 2014

2014-05-20T01:43:15Z

← Older revision		Revision as of 01:43, May 20, 2014
Line 5:		Line 5:
	'''Questions:'''		'''Questions:'''

	* [[#1\|What policies and/or mechanisms will your runtime use to schedule code and place data for 100M objects (executing code, data elements, etc.) in a scalable fashion?]]		* [[#table1\|What policies and/or mechanisms will your runtime use to schedule code and place data for 100M objects (executing code, data elements, etc.) in a scalable fashion?]]
	* [[#2\|What features will allow your runtime to dynamically adapt the schedule and placement for 100K sockets to improve the metrics of code-data affinity, power consumption, migration cost and resiliency?]]		* [[#table2\|What features will allow your runtime to dynamically adapt the schedule and placement for 100K sockets to improve the metrics of code-data affinity, power consumption, migration cost and resiliency?]]
	* [[#3\|How will the runtime manage resources (compute, memory, power, bandwidth) for 100K sockets to meet a power, energy and performance objective?]]		* [[#table3\|How will the runtime manage resources (compute, memory, power, bandwidth) for 100K sockets to meet a power, energy and performance objective?]]
	* [[#4\|How does the runtime software itself scale to 100K sockets? Specifically, how does it distribute, monitor and balance itself and how is it resilient to failures?]]		* [[#table4\|How does the runtime software itself scale to 100K sockets? Specifically, how does it distribute, monitor and balance itself and how is it resilient to failures?]]
	* [[#5\|What is the efficiency of the runtime? Specifically, how much impact does the runtime have on a) the total execution time of the application and b) resources taken from algorithmic computations? What are your plans to maximize efficiency? How will runtime overhead scale to 100K sockets?]]		* [[#5\|What is the efficiency of the runtime? Specifically, how much impact does the runtime have on a) the total execution time of the application and b) resources taken from algorithmic computations? What are your plans to maximize efficiency? How will runtime overhead scale to 100K sockets?]]
	* [[#6\|Do you support isolation of the runtime code from the user code to avoid violations and contamination?]]		* [[#6\|Do you support isolation of the runtime code from the user code to avoid violations and contamination?]]
Line 14:		Line 14:
	* [[#8\|What is your model for execution of multiple different programs (ie: a single mention would be doing more than one thing) in terms of division, isolation, containment and protection?]]		* [[#8\|What is your model for execution of multiple different programs (ie: a single mention would be doing more than one thing) in terms of division, isolation, containment and protection?]]

	<div id="#1"></div>{{ProjectTable		<div id="table1"></div>{{ProjectTable

	\|question=What policies and/or mechanisms will your runtime use to schedule code and place data for 100M objects (executing code, data elements, etc.) in a scalable fashion?		\|question=What policies and/or mechanisms will your runtime use to schedule code and place data for 100M objects (executing code, data elements, etc.) in a scalable fashion?
Line 40:		Line 40:
	}}		}}

	<div id="#2"></div>{{ProjectTable		<div id="table2"></div>{{ProjectTable

	\|question=What features will allow your runtime to dynamically adapt the schedule and placement for 100K sockets to improve the metrics of code-data affinity, power consumption, migration cost and resiliency?		\|question=What features will allow your runtime to dynamically adapt the schedule and placement for 100K sockets to improve the metrics of code-data affinity, power consumption, migration cost and resiliency?
Line 64:		Line 64:
	}}		}}

	{{ProjectTable		<div id="table3"></div>{{ProjectTable

	\|question=How will the runtime manage resources (compute, memory, power, bandwidth) for 100K sockets to meet a power, energy and performance objective?		\|question=How will the runtime manage resources (compute, memory, power, bandwidth) for 100K sockets to meet a power, energy and performance objective?

imported>Admin at 01:41, May 20, 2014

2014-05-20T01:41:43Z

← Older revision		Revision as of 01:41, May 20, 2014
Line 14:		Line 14:
	* [[#8\|What is your model for execution of multiple different programs (ie: a single mention would be doing more than one thing) in terms of division, isolation, containment and protection?]]		* [[#8\|What is your model for execution of multiple different programs (ie: a single mention would be doing more than one thing) in terms of division, isolation, containment and protection?]]

	{{ProjectTable		<div id="#1"></div>{{ProjectTable

	\|question=What policies and/or mechanisms will your runtime use to schedule code and place data for 100M objects (executing code, data elements, etc.) in a scalable fashion?		\|question=What policies and/or mechanisms will your runtime use to schedule code and place data for 100M objects (executing code, data elements, etc.) in a scalable fashion?
Line 40:		Line 40:
	}}		}}

	{{ProjectTable		<div id="#2"></div>{{ProjectTable

	\|question=What features will allow your runtime to dynamically adapt the schedule and placement for 100K sockets to improve the metrics of code-data affinity, power consumption, migration cost and resiliency?		\|question=What features will allow your runtime to dynamically adapt the schedule and placement for 100K sockets to improve the metrics of code-data affinity, power consumption, migration cost and resiliency?

imported>Admin at 01:25, May 20, 2014

2014-05-20T01:25:10Z

Show changes

imported>Admin at 01:07, May 20, 2014

2014-05-20T01:07:53Z

Show changes

imported>Admin at 01:00, May 20, 2014

2014-05-20T01:00:33Z

@@ Line 36: / Line 36: @@
 |charmplusplusanswer=Overdecomposition: A Charm++ program consists of a large number of objects assigned to the processors by the RTS. Initial placement of objects is controlled by map functions that are either system defined or user defined static functions. The RTS dynamically migrates objects across processors as needed. Message driven scheduling is used on individual processors: a message, containing a method invocation for an object, is selected by the scheduler and the corresponding object's execution is triggered.
-|earlycareeranswer=Work is assumed to be decomposed into finer-grained tasks. The specification of inter-task dependences and task-data relationships is used to automate aspects of locality management, load balance, and resilience. We investigate algorithms based on dynamic load balancing for various classes of inter-task and task-data relationships — strict computations, data-flow graphs, etc. — for intra-node and inter-node scheduling.
+|earlycareeranswer=Work is assumed to be decomposed into finer-grained tasks. The specification of inter-task dependencies and task-data relationships is used to automate aspects of locality management, load balance, and resilience. We investigate algorithms based on dynamic load balancing for various classes of inter-task and task-data relationships — strict computations, data-flow graphs, etc. — for intra-node and inter-node scheduling.
 }}
 {| class="wikitable"

imported>Admin at 00:54, May 20, 2014

2014-05-20T00:54:46Z

← Older revision		Revision as of 00:54, May 20, 2014
Line 39:		Line 39:

	}}		}}


	~~{\| class="wikitable"~~
	\| colspan="2" \| <span id="1"> '''What policies and/or mechanisms will your runtime use to schedule code and place data for 100M objects (executing code, data elements, etc.) in a scalable fashion?''' </span>
	\|-
	~~\| XPRESS \|\| {{{~~

	A hierarchical representation of logical contexts and tasks (processes and compute complexes) provides semantic representations of relative locality for placement of data objects and the tasks that are performed on them. Where data is widely distributed, they can be organized on separate processes distributed across multiple nodes with methods that allow actual work to be performed near the data. Research is exploring the allocation of resources by the LXK OS to the HPX runtime system and the policies to be implemented including programming interface semantics.
	\|-
	\| TG \|\| Open Community Runtime (OCR) will optimize for data-movement scalability. Our programming model divides an application into event-driven tasks with explicit data-dependences. Our runtime uses of this to schedule code close to its data or move the data close to the code. Scalability will be achieved through hierarchical task-stealing favoring locality.
	\|-
	\| DEGAS \|\| The DEGAS runtime uses one-sided communication (put, get, active messages, atomics, and remote enqueue of tasks) to place data and work across a large-scale machine. Within a node there are currently two scheduling approaches being pursued. One (under HCLib/Habanero-C) is built on OCR and uses a dynamic task scheduler; it is being evaluated to determine the need for locality control within the node; the second is derived from the UPC runtime and has both a fixed set of locality-aware threads tied to cores (or hardware threads or NUMA domains -- it's an abstraction that can be used a various machine levels), augmented with voluntary task scheduling for both locality and remotely generated dynamic tasks. A global task stealing scheduler is also part of the DEGAS plan and exists in prototype form; as with dynamic tasking, it is to be used on-demand for applications that are not naturally load balanced (e.g., divide-and-conquer problems with irregular trees).
	\|-
	\| D-TEC \|\| The APGAS (Asynchronous Partitioned Global Address Space) runtime uses a work-stealing scheduler to dynamically schedule tasks within a node. We are introducing areas to enable finer-grained locality and scheduling control within a node (Place). By design the runtime does not directly address automatic cross-node data placement. The APGAS runtime/programming model does provide primitive mechanisms (Places and Areas; at/async/finish) that allow application frameworks to productively implement data placement and cross-node scheduling frameworks on top of the runtime.
	\|-
	\| DynAX \|\| The SWift Adaptive Runtime Machine (SWARM) has a "locale" hierarchy, which roughly mirrors the hardware architecture hierarchy. Each locale has a set of local scheduler queues, allowing distributed and scalable scheduling. Data allocation and task/data migration are expressed to ensure proper parallelism around the conjunction. SWARM will rely on a single-assignment policy to prevent the need for globally coordinated checkout or write-back operations.
	\|-
	\| X-TUNE \|\| The compiler for X-TUNE must generate code with hierarchical threading, and will rely on the run-time to manage that threading efficiently. Point-to-point synchronization between threads may be more efficient than barriers to allow more dynamic behavior of the threads.
	\|-
	\| GVR \|\| GVR will use performance information for varied memory and storage types (DRAM, NVRAM, SSD, Disk), resource failure rate and prediction, redundancy in data encoding, existing version data copies and their location, as well as communication costs to place data. GVR does not include code scheduling mechanisms.
	\|-
	~~\| CORVETTE \|\|~~
	\|-
	\| SLEEC \|\| SLEEC does not have a true runtime component, except insofar as we are developing single-node runtimes to, e.g., manage data movement between cores and accelerators. We also perform small-scale inspector/executor-style scheduling for applications. However, we expect to rely on other systems for our large-scale runtime needs.
	\|-
	~~\| PIPER \|\| N/A~~
	\|-
	\| Charm++ \|\| Overdecomposition: A Charm++ program consists of a large number of objects assigned to the processors by the RTS. Initial placement of objects is controlled by map functions that are either system defined or user defined static functions. The RTS dynamically migrates objects across processors as needed. Message driven scheduling is used on individual processors: a message, containing a method invocation for an object, is selected by the scheduler and the corresponding object's execution is triggered.
	\|-
	\| Early Career-SriramK \|\| Work is assumed to be decomposed into finer-grained tasks. The specification of inter-task dependences and task-data relationships is used to automate aspects of locality management, load balance, and resilience. We investigate algorithms based on dynamic load balancing for various classes of inter-task and task-data relationships — strict computations, data-flow graphs, etc. — for intra-node and inter-node scheduling.
	\|-
	\|}

	{\| class="wikitable"		{\| class="wikitable"

imported>Admin at 00:53, May 20, 2014

2014-05-20T00:53:58Z

← Older revision		Revision as of 00:53, May 20, 2014
Line 15:		Line 15:

	{{ProjectTable		{{ProjectTable

	\|question=What policies and/or mechanisms will your runtime use to schedule code and place data for 100M objects (executing code, data elements, etc.) in a scalable fashion?		\|question=What policies and/or mechanisms will your runtime use to schedule code and place data for 100M objects (executing code, data elements, etc.) in a scalable fashion?

Line 35:		Line 36:
	\|charmplusplusanswer=Overdecomposition: A Charm++ program consists of a large number of objects assigned to the processors by the RTS. Initial placement of objects is controlled by map functions that are either system defined or user defined static functions. The RTS dynamically migrates objects across processors as needed. Message driven scheduling is used on individual processors: a message, containing a method invocation for an object, is selected by the scheduler and the corresponding object's execution is triggered.		\|charmplusplusanswer=Overdecomposition: A Charm++ program consists of a large number of objects assigned to the processors by the RTS. Initial placement of objects is controlled by map functions that are either system defined or user defined static functions. The RTS dynamically migrates objects across processors as needed. Message driven scheduling is used on individual processors: a message, containing a method invocation for an object, is selected by the scheduler and the corresponding object's execution is triggered.

	earlycareeranswer=Work is assumed to be decomposed into finer-grained tasks. The specification of inter-task dependences and task-data relationships is used to automate aspects of locality management, load balance, and resilience. We investigate algorithms based on dynamic load balancing for various classes of inter-task and task-data relationships — strict computations, data-flow graphs, etc. — for intra-node and inter-node scheduling.		\|earlycareeranswer=Work is assumed to be decomposed into finer-grained tasks. The specification of inter-task dependences and task-data relationships is used to automate aspects of locality management, load balance, and resilience. We investigate algorithms based on dynamic load balancing for various classes of inter-task and task-data relationships — strict computations, data-flow graphs, etc. — for intra-node and inter-node scheduling.

	}}		}}

imported>Admin at 00:52, May 20, 2014

2014-05-20T00:52:56Z

@@ Line 13: / Line 13: @@
 * [[#7|What specific hardware features do you require for proper or efficient runtime operation (atomics, DMA, F/E bits, etc.)?]]
 * [[#8|What is your model for execution of multiple different programs (ie: a single mention would be doing more than one thing) in terms of division, isolation, containment and protection?]]
 {{ProjectTable
 |question=What policies and/or mechanisms will your runtime use to schedule code and place data for 100M objects (executing code, data elements, etc.) in a scalable fashion?
 |xpressanswer=A hierarchical representation of logical contexts and tasks (processes and compute complexes) provides semantic representations of relative locality for placement of data objects and the tasks that are performed on them. Where data is widely distributed, they can be organized on separate processes distributed across multiple nodes with methods that allow actual work to be performed near the data. Research is exploring the allocation of resources by the LXK OS to the HPX runtime system and the policies to be implemented including programming interface semantics.
 |dynaxanswer=The SWift Adaptive Runtime Machine (SWARM) has a "locale" hierarchy, which roughly mirrors the hardware architecture hierarchy.  Each locale has a set of local scheduler queues, allowing distributed and scalable scheduling.  Data allocation and task/data migration are expressed to ensure proper parallelism around the conjunction.  SWARM will rely on a single-assignment policy to prevent the need for globally coordinated checkout or write-back operations.  }}

imported>Admin at 00:03, May 20, 2014

2014-05-20T00:03:13Z

← Older revision		Revision as of 00:03, May 20, 2014
Line 14:		Line 14:
	* [[#8\|What is your model for execution of multiple different programs (ie: a single mention would be doing more than one thing) in terms of division, isolation, containment and protection?]]		* [[#8\|What is your model for execution of multiple different programs (ie: a single mention would be doing more than one thing) in terms of division, isolation, containment and protection?]]

	{{QuestionTable}}		{{QuestionTable
			\|question1=My First Question
			\|question2=My Seccond Question
			}}

	{{ProjectTable		{{ProjectTable