NAMDPerformance - Revision history

Shirley at 21:18, 14 July 2009

2009-07-14T21:18:42Z

Shirley at 21:15, 14 July 2009

2009-07-14T21:15:37Z

Shirley: /* NAMD Performance Study */

2009-07-14T21:14:55Z

‎NAMD Performance Study

Scottb at 00:16, 10 June 2009

2009-06-10T00:16:48Z

Scottb at 00:12, 10 June 2009

2009-06-10T00:12:14Z

Scottb at 23:47, 9 June 2009

2009-06-09T23:47:30Z

Scottb at 23:43, 9 June 2009

2009-06-09T23:43:31Z

Scottb: New page: =NAMD Performance Study= NAMD is written in [http://charm.cs.uiuc.edu/ charm++] and thus has some unique attributes when profiled by TAU. For example charm++ scheduler which assigns task ...

2009-06-09T23:19:32Z

New page: =NAMD Performance Study= NAMD is written in [http://charm.cs.uiuc.edu/ charm++] and thus has some unique attributes when profiled by TAU. For example charm++ scheduler which assigns task ...

New page

=NAMD Performance Study=

NAMD is written in [http://charm.cs.uiuc.edu/ charm++] and thus has some unique attributes when profiled by TAU. For example charm++ scheduler which assigns task to processors and helps in load balancing the program has a notion of Idling while waiting for tasks to complete. TAU thus creates a event to capture time spent when the scheduler is in its idle state (Idle) as well as a event (main) to account for the communication latencies.

@@ Line 1: / Line 1: @@
 =NAMD Performance Study=
-NAMD is written in [http://charm.cs.uiuc.edu/ Charm++] and thus has some unique attributes when profiled by TAU. For example the Charm++ scheduler, which assigns task to processors and helps in load balancing the program, has a notion of idling while waiting for tasks to complete. Thus TAU creates a event to capture time spent when the scheduler is in its idle state (Idle) as well as a event (Main) to account for the communication latencies. You can see how NAMD performs on different hardware with these charts:
+NAMD is written in [http://charm.cs.uiuc.edu/ Charm++] and thus has some unique attributes when profiled by TAU. For example the Charm++ scheduler, which assigns task to processors and helps in load balancing the program, has a notion of idling while waiting for tasks to complete. Thus TAU creates an event to capture time spent when the scheduler is in its idle state (Idle) as well as an event (Main) to account for the communication latencies. You can see how NAMD performs on different hardware with these charts:
 [[Image:intrepid-ranger-breakdown.png]]
-Where on Intrepid (BlueGene P) Idle time (red) increases as NAMD scales on Ranger (Sun x86 cluster) Main time increases (blue). This shows how Rangers relatively slower communications layer results in larger latencies as NAMD scales compared to how NAMD scales on Intrepid.
+Whereas on Intrepid (BlueGene P) Idle time (red) increases as NAMD scales, on Ranger (Sun x86 cluster) Main time increases (blue). This shows how Ranger's relatively slower communications layer results in larger latencies as NAMD scales compared to how NAMD scales on Intrepid.
-The ability for NAMD to scale to a large number of processors is highly dependent on how it is configured. Many options are provided to tweak NAMD's performance structure to optimize performance for different simulation parameters and machines. So insteed of focusing on NAMD's scaling behavior we showed how TAU can identify other performance aspects of NAMD. This chart shows the the incressing variation across processors for varius NAMD events. Notice how after each load balancing phase the divergence among processors is temporally arrested.
+The ability of NAMD to scale to a large number of processors is highly dependent on how it is configured. Many options are provided to tweak NAMD's performance structure to optimize performance for different simulation parameters and machines. So instead of focusing on NAMD's scaling behavior, we showed how TAU can identify other performance aspects of NAMD. This chart shows the the increasing variation across processors for varius NAMD events. Notice how after each load balancing phase the divergence among processors is temporally arrested.
 [[Image:namd-deviation-snapshot.png|800px]]

@@ Line 1: / Line 1: @@
 =NAMD Performance Study=
-NAMD is written in [http://charm.cs.uiuc.edu/ charm++] and thus has some unique attributes when profiled by TAU. For example the Charm++ scheduler, which assigns task to processors and helps in load balancing the program, has a notion of idling while waiting for tasks to complete. Thus TAU creates a event to capture time spent when the scheduler is in its idle state (Idle) as well as a event (Main) to account for the communication latencies. You can see how NAMD performs on different hardware with these charts:
+NAMD is written in [http://charm.cs.uiuc.edu/ Charm++] and thus has some unique attributes when profiled by TAU. For example the Charm++ scheduler, which assigns task to processors and helps in load balancing the program, has a notion of idling while waiting for tasks to complete. Thus TAU creates a event to capture time spent when the scheduler is in its idle state (Idle) as well as a event (Main) to account for the communication latencies. You can see how NAMD performs on different hardware with these charts:
 [[Image:intrepid-ranger-breakdown.png]]

@@ Line 1: / Line 1: @@
 =NAMD Performance Study=
-NAMD is written in [http://charm.cs.uiuc.edu/ charm++] and thus has some unique attributes when profiled by TAU. For example the charm++ scheduler, which assigns task to processors and helps in load balancing the program, has a notion of Idling while waiting for tasks to complete. Thus TAU creates a event to capture time spent when the scheduler is in its idle state (Idle) as well as a event (Main) to account for the communication latencies. You can see how NAMD performs on different hardware with these charts:
+NAMD is written in [http://charm.cs.uiuc.edu/ charm++] and thus has some unique attributes when profiled by TAU. For example the Charm++ scheduler, which assigns task to processors and helps in load balancing the program, has a notion of idling while waiting for tasks to complete. Thus TAU creates a event to capture time spent when the scheduler is in its idle state (Idle) as well as a event (Main) to account for the communication latencies. You can see how NAMD performs on different hardware with these charts:
 [[Image:intrepid-ranger-breakdown.png]]

@@ Line 3: / Line 3: @@
 NAMD is written in [http://charm.cs.uiuc.edu/ charm++] and thus has some unique attributes when profiled by TAU. For example the charm++ scheduler, which assigns task to processors and helps in load balancing the program, has a notion of Idling while waiting for tasks to complete. Thus TAU creates a event to capture time spent when the scheduler is in its idle state (Idle) as well as a event (Main) to account for the communication latencies. You can see how NAMD performs on different hardware with these charts:
-[Image:intrepid-ranger-breakdown.png]
+[[Image:intrepid-ranger-breakdown.png]]
 Where on Intrepid (BlueGene P) Idle time (red) increases as NAMD scales on Ranger (Sun x86 cluster) Main time increases (blue). This shows how Rangers relatively slower communications layer results in larger latencies as NAMD scales compared to how NAMD scales on Intrepid.
@@ Line 10: / Line 10: @@
 The ability for NAMD to scale to a large number of processors is highly dependent on how it is configured. Many options are provided to tweak NAMD's performance structure to optimize performance for different simulation parameters and machines. So insteed of focusing on NAMD's scaling behavior we showed how TAU can identify other performance aspects of NAMD. This chart shows the the incressing variation across processors for varius NAMD events. Notice how after each load balancing phase the divergence among processors is temporally arrested.
-[Image:namd-deviation-snapshot.png|800px]
+[[Image:namd-deviation-snapshot.png|800px]]

← Older revision		Revision as of 00:12, 10 June 2009
Line 6:		Line 6:

	Where on Intrepid (BlueGene P) Idle time (red) increases as NAMD scales on Ranger (Sun x86 cluster) Main time increases (blue). This shows how Rangers relatively slower communications layer results in larger latencies as NAMD scales compared to how NAMD scales on Intrepid.		Where on Intrepid (BlueGene P) Idle time (red) increases as NAMD scales on Ranger (Sun x86 cluster) Main time increases (blue). This shows how Rangers relatively slower communications layer results in larger latencies as NAMD scales compared to how NAMD scales on Intrepid.
		+
		+
		+	The ability for NAMD to scale to a large number of processors is highly dependent on how it is configured. Many options are provided to tweak NAMD's performance structure to optimize performance for different simulation parameters and machines. So insteed of focusing on NAMD's scaling behavior we showed how TAU can identify other performance aspects of NAMD. This chart shows the the incressing variation across processors for varius NAMD events. Notice how after each load balancing phase the divergence among processors is temporally arrested.
		+
		+	[Image:namd-deviation-snapshot.png\|800px]

← Older revision		Revision as of 23:47, 9 June 2009
Line 3:		Line 3:
	NAMD is written in [http://charm.cs.uiuc.edu/ charm++] and thus has some unique attributes when profiled by TAU. For example the charm++ scheduler, which assigns task to processors and helps in load balancing the program, has a notion of Idling while waiting for tasks to complete. Thus TAU creates a event to capture time spent when the scheduler is in its idle state (Idle) as well as a event (Main) to account for the communication latencies. You can see how NAMD performs on different hardware with these charts:		NAMD is written in [http://charm.cs.uiuc.edu/ charm++] and thus has some unique attributes when profiled by TAU. For example the charm++ scheduler, which assigns task to processors and helps in load balancing the program, has a notion of Idling while waiting for tasks to complete. Thus TAU creates a event to capture time spent when the scheduler is in its idle state (Idle) as well as a event (Main) to account for the communication latencies. You can see how NAMD performs on different hardware with these charts:

		+	[Image:intrepid-ranger-breakdown.png]

−	Where on Intrepid (BlueGene P) Idle time (red) increases as NAMD scales on Ranger (Sun x86 cluster) Main time ~~increses~~ (blue). This shows how Rangers relatively slower communications layer results in larger latencies as NAMD scales.	+	Where on Intrepid (BlueGene P) Idle time (red) increases as NAMD scales on Ranger (Sun x86 cluster) Main time increases (blue). This shows how Rangers relatively slower communications layer results in larger latencies as NAMD scales compared to how NAMD scales on Intrepid.

← Older revision		Revision as of 23:43, 9 June 2009
Line 1:		Line 1:
	=NAMD Performance Study=		=NAMD Performance Study=

−	NAMD is written in [http://charm.cs.uiuc.edu/ charm++] and thus has some unique attributes when profiled by TAU. For example charm++ scheduler which assigns task to processors and helps in load balancing the program has a notion of Idling while waiting for tasks to complete. TAU ~~thus~~ creates a event to capture time spent when the scheduler is in its idle state (Idle) as well as a event (~~main~~) to account for the communication latencies.	+	NAMD is written in [http://charm.cs.uiuc.edu/ charm++] and thus has some unique attributes when profiled by TAU. For example the charm++ scheduler, which assigns task to processors and helps in load balancing the program, has a notion of Idling while waiting for tasks to complete. Thus TAU creates a event to capture time spent when the scheduler is in its idle state (Idle) as well as a event (Main) to account for the communication latencies. You can see how NAMD performs on different hardware with these charts:
		+
		+
		+	Where on Intrepid (BlueGene P) Idle time (red) increases as NAMD scales on Ranger (Sun x86 cluster) Main time increses (blue). This shows how Rangers relatively slower communications layer results in larger latencies as NAMD scales.