
	Where results make sense

Topic: Embarrassingly parallel problem

Related Topics

Grid computing

Supercomputer

Superscalar

Seymour Cray

RISC

CDC 6600

Maceo

Classical Hebrew

Ice cores

ZDTV

John Mercer Patton

Leonid Kizim

Chi Rho

Department of Justice and Police

Parallel computing

In the News (Fri 11 Dec 09)

Northern Trust

Marvin Harrison

Peter Chernin

Gary Locke

Match Play

Penelope Cruz

Mickey Rourke

AR Rahman

Danny Boyle

Hugh Jackman

	HPC Challenge Benchmark Results - Global and per Processor Results - Optimized Runs Only - 21 Systems - Generated on ...
		The Embarrassingly Parallel STREAM benchmark is a simple synthetic benchmark program that measures sustainable memory bandwidth and the corresponding computation rate for simple numerical vector kernels.
		It is run in embarrassingly parallel manner - all computational nodes perform the benchmark at the same time, the arithmetic average rate is reported.
		Embarrassingly Parallel DGEMM, benchmark measures the floating-point execution rate of double precision real matrix-matrix multiply performed by the DGEMM subroutine from the BLAS (Basic Linear Algebra Subprograms).
	icl.cs.utk.edu /hpcc/hpcc_results_per_proc.cgi?display=opt (1213 words)

	[No title]
		This requires that each timestep be a function of the results for all previous timesteps, which is not an embarrasingly parallel problem and will require distribution of the ions in the simulation cell across multiple processors, with one node consolidating results and calculating statistical averages at each timestep.
		There are easy, less efficient ways of doing a parallel implementation of these codes, since the point calculations are more or less independent, but processing time for each calculation varies dramatically and not entirely predictably (due to the fact that the sample size is dynamic), so load balancing across nodes is not trivial.
		I have yet to develop a serial version of this specialized problem, though it is potentially the most interesting from a parallel computing point of view.
	web.mit.edu /brandonw/www/18.337_project_proposal.html (839 words)

	IMAGER: A Parallel Interface to Spectral Line Processing
		Our test problem was the imaging (uvmap) and CLEAN deconvolution (clean) of a single pointing observation of the molecular gas (the CS line) associated with the ``sickle'' HII region near the Galactic center.
		One of the goals of this project was to demonstrate the ease of programming and use of a embarrassingly parallel data reduction package.
		Parallel functionality at some level should be available in AIPS++ by the time of the first full release of AIPS++ in mid-1997.
	www.cv.nrao.edu /adass/adassVI/robertsd.html (1544 words)

	Parallel Computing Examples and Explanations
		Parallelizing each job and then running these parallelizations one after another is probably a less efficient way of doing the work.
		Embarrassingly parallel is simple, though if you can get the workers do it for free, then perhaps you are quite clever.
		In fact, sometimes people are forced to rethink the problem when they try to develop a parallel program, and they change their entire approach in order to directly utilize the inherent parallelism.
	www.eecs.umich.edu /~qstout/parallel.html (1485 words)

	Journal of Science & Technology
		Embarrassingly Parallel: The problem is decomposed into a set of independent tasks.
		Geometric Decomposition: The problem space is decomposed into discrete subspaces; the problem is then solved by computing solutions for the subspaces, with the solution for each subspace typically requiring data from a small number of other subspaces.
		With this strategy, a problem is solved by splitting it into subproblems, solving them independently, and merging their solutions into a solution for the whole problem.
	www.ust.edu /sj/Synthesizing.htm (3550 words)

	Introduction to MPI Distributed Programming With Mac OS X
		Xgrid is especially well suited for "embarrassingly parallel" problems, which run the exact same code many times using different inputs (e.g., different random numbers for a Monte Carlo simulation, or different input files for finite element analysis).
		It therefore is possible for the same parallel application to remain unchanged, at least at a source-code level, and execute correctly on a wide range of parallel computing hardware and software.
		A problem could occur because of an incorrectly specified address, to which many command-line based MPI implementations are susceptible because they often rely on static files containing address lists.
	developer.apple.com /hardware/hpc/mpionmacosx.html (2698 words)

	A Compilation of Discussion on Parallel Languages by Greg Pfister, IBM \| Scalable Computing (Site not responding. Last check: 2007-11-06)
		I have found that wringing sufficient parallelism out of existing algorithms which are not a so-called "embarrassingly parallel" problem involves so much application-domain knowledge (for algorithm rewriting) and fine tuning that a parallel language probably wouldn't deliver.
		The problem is that the low cost of commodity clusters and the high portability of apps in MPI have discouraged the continued development of anything but a cluster, but in fact there are a few very important applications that don't work at all well on such clusters.
		Whatever CS folks think, the only reason parallel computers get used in practice, given their relatively high cost, is to work on large-scale problems that cannot be solved serially because they are memory-intensive or compute-intensive.
	www.ieeetcsc.org /newsletters/2006-01/why_all_mpi_discussion.html (5522 words)

	7.1 Embarrassingly Parallel Problem Structure
		In Chapters 4 and 6, we studied the synchronous problem class where the uniformity of the computation, that is, of the temporal structure, made the parallel implementation relatively straightforward.
		One important feature of embarrassingly parallel problems is the modest node-to-node communication requirements-the definition of no spatial connection implies in fact no internode communication, but a practical problem would involve some amount of communication, if only to set up the problem and accumulate results.
		The embarrassingly parallel gravitational lens application of Section 7.4 was frustrating for the developers as it needed software support not available at the time on the Mark III.
	www.netlib.org /utk/lsi/pcwLSI/text/node132.html (638 words)

	Distributed Multiprocessor Environments
		The simplest parallel programming is for what are called "embarrassingly parallel problems" [16] (requiring minimal interprocess communications) done on a computer with more than one processor.
		This suggests a preliminary problem: determination of the sizes of the partitions, a problem that amounts to determining the values for a histogram.
		The problem assigned to the students for their own programming was generated by taking Dijkstra’s railroad problem of two-way travel on a single track (transformed by Tanenbaum into baboons crossing a rope, [25] but transformed back to a railroad problem) and formulating it for solution based on message passing rather than semaphores.
	penguin.ewu.edu /~trolfe/CCSC2002/Distrib.html (3429 words)

	High-performance Computers - Chapter 4
		So-called "embarrassingly parallel" applications are those that lend themselves to decompositions in which a great deal of computation can be performed with very little communication between processors.
		Even for applications that are not embarrassingly parallel, the ratio of computation to communication can sometimes be improved by increasing the granularity of the problem, or the portion of the problem handled by a single processor.
		Even before considering issues of parallelism, a CFD code must be revised to handle the differences in memory between the vector shared-memory model and the parallel distributed-memory model.
	web.elastic.org /~fche/mirrors/www.jya.com/hpc/chap4.htm (16779 words)

	National Partnership for Advanced Computational Infrastructure: Archives
		These problems with random number generators on sequential, as well as vector computers, only get worse on parallel supercomputers where parallel random number generators are required.
		One problem with LFG is that i words of memory must be kept current, whereas LCG requires only that the last value of X be saved.
		Another possible problem is that long-range correlations that exist in serial generators could become short-range inter-stream or inter-processor correlations in parallel generators (Refs.11).
	www.npaci.edu /online/v3.7/SCAN1.html (3511 words)

	raganwald: Hard-Core Concurrency Considerations
		The problem is that Haskell purely-functional model doesn’t support multiple-CPU’s (it’s true, check the literature (except for specialized pipelined architectures, but not in the general case)).
		The problem of synchronizing your data-structure appears to be eliminated, but it has really just been moved up to the top-level “state” structure (monad), where the problem is actually compounded.
		This isn’t a problem if you can partition your threads to work in different areas but my original email to Reg was about what to do when you do have a need for concurrent updates.
	weblog.raganwald.com /2007/05/hard-core-concurrency-considerations.html (4612 words)

	GridCafé - Grid at work - Computational problems
		In practice, fine-grained parallel calculations require very clever programming to make the most of their parallelism, so that the right information is available to processors at the right time.
		Another example of embarrassingly parallel is the analysis of a large databank of medical images, where each image is independent of the others.
		On the other hand, embarrassingly parallel calculations are ideal for a more loosely-coupled network of computers, since delays in getting results from one processors will not affect the work of the others.
	gridcafe.web.cern.ch /Gridcafe/gridatwork/applications/compu-problems.html (572 words)

	Project Proposal (Site not responding. Last check: 2007-11-06)
		Parallelize the ray tracer using MPI on a multiprocessor machine or cluster.
		This is an embarrassingly parallel problem, requiring no communication between processors, except for data distribution and recombination.
		The problem is being able to flood the unit with enough data requiring the same operations, without stalling the pipeline.
	www.cs.rit.edu /~brk3095/cg2/proposal.html (344 words)

	ProActive : NAS Parallel Benchmarks
		The NAS Parallel Benchmarks (NPB) are a small set of programs designed to help evaluate the performance of parallel supercomputers.
		There are 6 classes of problems : S, W, A, B, C and D. Class S is the easiest problem and is for test purpose only.
		It means that no particular effort is needed to segment the problem into a very large number of parallel tasks, and there is no essential dependency (or communication) between those parallel tasks.
	proactive.inria.fr /nas_benchmarks.htm (969 words)

	Asynchronous Problems and a Summary of Basic Problem Classes
		This class is caricatured in Figure 14.1 and is the last and hardest to parallelize of the basic problem architectures introduced in Section 3.4.
		The synchronous and embarrassingly parallel problem classes (54%) are those directly supported by the initial High Performance Fortran language [Fox:91e], [Kennedy:93a].
		This was implemented in parallel as a ``best-first'' and not a ``depth-first'' search strategy and was applied to the travelling salesman problem (Section 11.4) to find exact solutions to test the physical optimization algorithms.
	www.netlib.org /utk/lsi/pcwLSI/text/node335.html (1489 words)

	Codeplay: Portable High-Performance Compilers
		So, developers investing large amounts of time and money in parallelizing for any existing processor architecture has to consider that there investment may be very short-lived and they have to switch to a completely new programming model in a few years time.
		This appears to be embarrassingly parallel, and we would quite reasonably expect run-time to approach Â½ of the serial run-time.
		The problem is that both cores are simultaneously accessing main memory all the time, and the bus cannot cope.
	codeplaysoftware.typepad.com /codeplay (1772 words)

	Google's Folding@Home on the "Multi-Core Crisis"
		If anything this is where the fun CS problems are, and where the active research is. 10 years ago noone even thought you could distribute these problems and had to use supercomputers.
		Also appropriate to this discussion, even the number of "embarrassingly parallel" applications is going to explode beyond the obvious.
		Admittedly, the old embedded multi-threading problems I worked with are slightly different from the current issues brought upon by true multi-core chips.
	radar.oreilly.com /archives/2007/06/googles_folding.html (2610 words)

	Distributed Algorithm.
		gravitation problems (another long range interaction) that might be relevant at Linux Expo (the one in Raleigh a year and a half ago) that are probably in the proceedings.
		If you CAN run your problem with all N nodes on a single system, and need to run it many independent times (M times, in fact) for N node strings, you can run the M calculations in parallel on M computation nodes and still complete the N*M work in N time.
		The final note is that there are circumstances where it is worth it to parallelize a problem even when it scales poorly (even when it scales "negatively").
	www.beowulf.org /archive/2000-December/001541.html (673 words)

	Introduction to Parallel Computing
		Parallel computing is an evolution of serial computing that attempts to emulate what has always been the state of affairs in the natural world: many complex, interrelated events happening at the same time, yet within a sequence.
		Problems that increase the percentage of parallel time with their size are more scalable than problems with a fixed percentage of parallel time.
		The amount of memory required can be greater for parallel codes than serial codes, due to the need to replicate data and for overheads associated with parallel support libraries and subsystems.
	www.llnl.gov /computing/tutorials/parallel_comp (8237 words)

	Synthesizing a Parallel Sorting Algorithms based on Design Patterns
		Sorting is arguably the most studied problem in Computer Science, both because of its intrinsic theoretical importance and its use in so many applications.
		An ontology formally defines a common set of terms that are used to describe and represent a domain.
		Looking at a problem and finding concurrency that can be effectively exploited is a difficult problem.
	www.ust.edu /journal/synthesizing.php (3568 words)

	Homework 1: Grid of Resistors
		The problem is to compute the voltages and the effective resistance of a 2n+1 by 2n+2 grid of 1 ohm resistors if a battery is connected to the two center points.
		This is certainly not the fastest way to solve the problem, but it does illustrate many important programming ideas.
		The independent node updates are done in parallel using the mm-mode, and the communication is done by the high-level *p-syntax instead of explicit sends and receives.
	beowulf.lcs.mit.edu /18.337-2004/hw1 (1075 words)

	8.3 Parallel Computing Software
		PVM (Parallel Virtual Machine) is one of the first widely used message passing programming systems.
		In data parallel programming, we specify which processor owns what data, and the owner of the data does the computation on the data (Owner-computes rule).
		statement is a data parallel construct that defines the assignment of multiple elements in an array but does not restrict the order of assignment to individual elements.
	www.quantlet.com /mdstat/scripts/csa/html/node66.html (3551 words)

	Microparallelism and High-Performance Protein Matching
		As with the other forms of parallelism, the operations being executed in parallel correspond to independent reference strings, and these strings should be chosen to be roughly the same length.
		This problem can be circumvented by using a hybrid algorithm that uses the second semiring for substrings up to a certain length, combines the scores for the substrings in the first semiring.
		For time consuming problems such as this, it is often desirable to get the faster turnaround time provided by a parallel supercomputer or workstation cluster.
	www-cse.ucsd.edu /users/carter/Micro/sc95.html (4057 words)

	GRIDtoday: GRID PLUGTEST: INTEROPERABILITY ON THE GRID
		Regarding ProActive, it is an LGPL Java library for parallel, distributed and concurrent computing, also featuring mobility and security in a uniform framework.
		Indeed, the deployment on the different sites was not a source of problems, which is an indicator of how ProActive is fit for usage, as users were not bothered by system configuration, and could instead focus on the internals of their application.
		The application used for the contest and interoperability Plugtest is not yet fixed, but we have been thinking about a travel sales man problem, which needs many more communications, and will be even more interesting and demanding to supervise.
	www.gridtoday.com /05/0131/104537.html (1205 words)

	From QuickDraw to Quartz 2D > Graphics Programming in the Modern Age (Site not responding. Last check: 2007-11-06)
		Many of the algorithms that the GPU runs are what computer scientists call "embarrassingly parallel." An embarrassingly parallel problem is one in which a computer can easily work up a solution breaking it into smaller pieces and computing each piece along a parallel path.
		Each of the parallel units in a GPU is much simpler than its counterpart in a more general vector processor.
		Even though the parallel execution units of graphics cards can only perform a limited number of operations, those operations can be applied to solve problems that have nothing to do with graphics.
	www.awprofessional.com /articles/article.asp?p=454786&seqNum=2 (2532 words)

	Ray Tracing News, Volume 7, Number 2
		The problem is that the four newly created triangles aren't exactly the same size due to the sphere's curvature.
		In parallel computing literature, you also can find lots of paper talking about how to schedule this kind embarrassed paralleling problem (even though their problem is not ray tracing).
		The problem was treated as a global energy minimization problem, where energy was related to elastic deformation of the texture map.
	www.acm.org /tog/resources/RTNews/html/rtnv7n2.html (8358 words)

	Index
		3.5 Spatial Properties of, 7.1 Embarrassingly Parallel Problem, Asynchronous Problems and
		2.4 Summary, 3.5 Spatial Properties of, 4.3.6 QCD on the, 5.2.9 The Crystal Router, 5.2.9 The Crystal Router, 5.3.1 Introduction and History, 6.2.3 Parallel Issues, (,), (,), 11.1.2 The Optimization Problem, 16.1 Overview of Zipcode, 18.3.2 The Run-Time Environment-the
		5.2.8 A Ray Tracer-and, 7.1 Embarrassingly Parallel Problem, 7.4 Statistical Gravitational Lensing, Asynchronous Problems and
	www.netlib.org /utk/lsi/pcwLSI/text/node484.html (1983 words)

Try your search on: Qwika (all wikis)