text:
|Message view
|« Date » · « Thread »
|« Date » · « Thread »
|Emir Mahmut BAHSI <emba...@yahoo.com>
|Re: AW: AW: while-like structure in Ant
|Tue, 31 Jul 2007 17:34:51 GMT
Thanks for the information Jan. I am using both 'http' condition and 'get' task in my problem. I really want to know how can I create an 'http' condition in the javascript code below? >>myhttp = project.createTask("http"); >>myhttp.setUrl("a url address"); In the code above createTask is not appropriate I think since 'http' is not a task. But how could I correct it? Any suggestion? Emir email@example.com wrote: A condition is a different thing than a task - a condition checks something - a task does something. Of course an implementing class maybe can do both ( ). For HTTP there are two different implementations: - condition - task (- http AntLib http://ant.apache.org/antlibs/sandbox.html ) Jan >-----Ursprüngliche Nachricht----- >Von: Emir Mahmut BAHSI [mailto:firstname.lastname@example.com] >Gesendet: Montag, 30. Juli 2007 23:34 >An: Ant Users List >Betreff: Re: AW: while-like structure in Ant > >It is a good point! Http task is one of the core conditions >that can be used as a nested element in condition task. >FYI: http://ant.apache.org/manual/CoreTasks/conditions.html > >However I do not know why it is not listed in the manual as a >core task :) May be it is because of being a nested element >for condition task (core condition). > >Emir M Bahsi > >email@example.com wrote: Which task? Ant Core doesnt >have one. > >Jan > >>-----Ursprüngliche Nachricht----- >>Von: Emir Mahmut BAHSI [mailto:email@example.com] >>Gesendet: Sonntag, 29. Juli 2007 00:27 >>An: Ant Users List >>Betreff: RE: while-like structure in Ant >> >>Sorry everybody for the late replay. I am trying to implement >>that while structure as I explained before. I am using >>javascript for that. However, I can not create a http task in >>javascript code. That part of the code is: >> >>myhttp = project.createTask("http"); >>myhttp.setUrl("a url address"); >> >>The error is: javax.script.ScriptException: >>sun.org.mozilla.javascript.internal.EcmaError: TypeError: >>Cannot call method "setUrl" of null <#5> in >> at line number 5 >> >>Any help is appreciated. Thanks in advance. >> >>Emir Mahmut Bahsi >> >> >> >> >> >> >>"Rebhan, Gilbert" wrote: >>-----Original Message----- >>From: Xavier Hanin [mailto:firstname.lastname@example.com] >>Sent: Thursday, May 10, 2007 9:17 AM >>To: Ant Users List >>Subject: Re: while-like structure in Ant >> >>On 5/10/07, Emir Mahmut BAHSI wrote: >>> >>> Hi all, >>> I have been working on conditional structures and loop structures on >>> existing workflow managers for a long time. For this purpose I have >>> implemented two simple examples for if-type and switch-type cases >>(examples >>> are attached). In these examples my program is simply downloading a >>file. If >>> that file does not exist in the first web address it tries another >>address. >>> However, I could not implement a loop structure for that. >In the loop >>case >>> the program should try the same address until the file exists. >>Actually I >>> know this is not a reasonable and useful scenario but I just want to >>show >>> whether a conditional-loop scenario can be implemented in Ant. >>> >>> Can u suggest me anything to implement that example. Any help is >>> appreciated. >> >>/* >>The ant-contrib project is providing conditional tasks which may help, >>but >>if you want to have your own syntax and the very specific url >>availability >>as a condition (like you wrote), maybe using a script (using scriptdef >>for >>example) would be a good fit. >>*/ >> >>+1 >> >>i would go via and a scripting language running in >>BSF >>(JRuby, Groovy, Beanshell ... ) >> >>or use the AntBuilder@Groovy >> >>see = >>http://groovy.codehaus.org/ >>http://www.bytemycode.com/snippets/snippet/475/ >> >>Regards, Gilbert >> >> >> >>--------------------------------------------------------------------- >>To unsubscribe, e-mail: email@example.com >>For additional commands, e-mail: email@example.com >> >> >> >> >>--------------------------------- >>Take the Internet to Go: Yahoo!Go puts the Internet in your >>pocket: mail, news, photos & more. >> > >--------------------------------------------------------------------- >To unsubscribe, e-mail: email@example.com >For additional commands, e-mail: email@example.com > > > > >--------------------------------- >Building a website is a piece of cake. >Yahoo! Small Business gives you all the tools to get online. > --------------------------------------------------------------------- To unsubscribe, e-mail: firstname.lastname@example.com For additional commands, e-mail: firstname.lastname@example.com --------------------------------- Pinpoint customers who are looking for what you sell.
|View raw message


text:
"Charlie Kelly: King of the Rats" is the tenth episode of the sixth season of It's Always Sunny in Philadelphia.
Keeping the basement rodent-free drives Charlie to the brink; The Gang throws Charlie a surprise party.
10:00 AM on a Tuesday, Philadelphia, PA
In the bar, The Gang are talking when Charlie comes in, zoned out from bashing rats in the basement. He proclaims he killed a nest of about 200 rats and wonders if a rats life is more important than a humans.
- Charlie Day as Charlie Kelly
- Glenn Howerton as Dennis Reynolds
- Rob McElhenney as Mac
- Kaitlin Olson as Dee Reynolds
- Danny DeVito as Frank Reynolds
Guest StarringEdit
- Chad L. Coleman as Z
- David Aranovich as Sakky the Ticket Usher
- David Gueriera as Duncan
- David Ury as Spa Worker
- Xuyen Valdivia as Stunt Male
- Lauren Mary Kim as Stunt Female
- The title picture of this page - it's a shot from the deleted ending scene for this episode.
- Frank had mentioned meeting people "down by the bridge" previously in "Mac and Charlie Die (Part 1)". Also, in "Mac's Mom Burns Her House Down" Frank was going to dump Dee under the bridge.
- A "little puppy", which Charlie was making outside of the bar, named Scarcoon ("Scary coon"): he is not able to kill the rats anymore, so he needs this raccoon just to scare them away.
- "A guy with a wormhat - like, his hat is made out of worms. And, like,
a little bird with human teeth" - all are products of Charlie Day's improvisation, which you can see in an extended scene of Mac and Charlie's brainstorming from "Mac and Charlie Write a Movie".
- David Gueriera ("Duncan") has previously twice appeared in the show as completely different characters: in The Gang Sells Out and The Gang Cracks the Liberty Bell.
- The opening scene where Charlie talks about killing rats is the scene that convinced Director Guillermo del Toro to cast Day in the role of Dr. Newton Geizler in the movie Pacific Rim.
|"Hey, where'd you get those glasses, bud?"
|"Oh, these? They're just, like, third-dimension glasses, you know? Don't really work though, 'cause I feel like I'm still seeing stuff in whatever dimension we live in..."
|"Do any of you assholes wanna know how old I am?"
|"Whatever, Frank."
|Season 6 Episodes
| 1. "Mac Fights Gay Marriage"
2. "Dennis Gets Divorced"
3. "The Gang Buys a Boat"
4. "Mac's Big Break"
5. "Mac and Charlie: White Trash"
6. "Mac's Mom Burns Her House Down"
|7. "Who Got Dee Pregnant?"
8. "The Gang Gets a New Member"
9. "Dee Reynolds: Shaping America's Youth"
10. "Charlie Kelly: King of the Rats"
11. "The Gang Gets Stranded in the Woods"
12. "Dee Gives Birth"

subset: commoncrawl


text:
According to IoDSA, the fact that many CEOs are staying in the job for too long is reason enough to develop a formal policy regarding their tenure.
The institute says when CEOs stay for too long, which is usually the case in family businesses, and businesses where a charismatic founder is the CEO, this puts the company and the CEO's legacy at risk.
The CEO of IoDSA, Ansie Ramalho says in a statement: 'Boards would probably be well advised to develop a formal policy relating to CEO tenure and what indicators should be used to determine when it should be terminated to protect the company and the CEO's own legacy. In this regard, leaders should actually be grateful for a way of determining more objectively when it's time to move on—many a career has been blighted by staying on too long in one place.'
Ramalho's comments come after a recent study published in the Strategic Management Journal, which links the length of a CEO's tenure with the performance of the companies they run.
Here's what the researchers found.
*********** Product endorsement ************
Your very own labour lawyer 24/7 at a fraction of the cost…
How much would you pay for a consultation with a labour lawyer? Some charge up to R2500 per hour! The Labour Law for Managers Loose Leaf Service will turn you into your very own labour expert!
You don't have to pay exorbitant amounts of money for advice anymore – you'll have all your questions answered in the handbook and what you don't find there, you can simply ask our panel of online experts- free.
We offer a specialised online advisory service where you can ask your question and receive an answer WITHIN 72 HOURS!
Researchers from Temple University and the University of Missouri examined 365 US companies between 2000 and 2010. The primary focus was to examine how the length of CEO tenure affected both firm-employee and firm-customer relationships.
The researchers concluded that while long tenures by CEOs can help to build solid relationships between the company and its employees, there's also a negative connection between a CEO's tenure and relations between the company and its customers.
They say this is due to the fact that new CEOs tend to be externally focused with a high level of interest in customer feedback and market intelligence. But as time goes on, 'they tend to turn inwards, relying more and more on internal sources of information and tried-and-trusted paradigms.'
The research found that the optimal term for CEOs in respect of firm-customer relations is 4.8 years.
This study suggests complacency is bad for business. And the IoDSA believes developing a formal policy regarding your CEO's tenure will help you overcome this complacency so your business can continue to thrive.
Recommended for You
Quick Tax Solutions for Busy Taxpayers – 35 tax answers at a glance
Here are all the most interesting, thought-provoking and common tax questions
asked by our subscribers over the last tax year – everything from A to Z!
To download Quick Tax Solutions for Busy Taxpayers – 35 tax answers at a glance click here now >>>
Employees always sick? How to stop it today
Make sure you develop a leave policy to regulate sick leave in your company.
BONUS! You'll find an example of the leave policy and procedure in this report.
To download Employees always sick? How to stop it today click here now >>>
Absenteeism: Little known ways to reduce absenteeism
This FREE e-report will tell you how you can reduce absenteeism in your workplace while avoiding the CCMA and without infringing your employees' labour rights.
To download Absenteeism: Little known ways to reduce absenteeism click here now >>>
7 Health & safety strategies to save you thousands
Don't let a health and safety incident cost you one more cent. Implement these seven
strategies in your company today.
To download 7 Health & safety strategies to save you thousands click here now >>>


text:
When Prefetching Works, When It Doesn t, and Why
- Kristina Snow
- 2 years ago
- Views:
1 When Prefetching Works, When It Doesn t, and Why JAEKYU LEE, HYESOON KIM, and RICHARD VUDUC, Georgia Institute of Technology In emerging and future high-end processor systems, tolerating increasing cache miss latency and properly managing memory bandwidth will be critical to achieving high performance. Prefetching, in both hardware and software, is among our most important available techniques for doing so; yet, we claim that prefetching is perhaps also the least well-understood. Thus, the goal of this study is to develop a novel, foundational understanding of both the benefits and limitations of hardware and software prefetching. Our study includes: source code-level analysis, to help in understanding the practical strengths and weaknesses of compiler- and software-based prefetching; a study of the synergistic and antagonistic effects between software and hardware prefetching; and an evaluation of hardware prefetching training policies in the presence of software prefetching requests. We use both simulation and measurement on real systems. We find, for instance, that although there are many opportunities for compilers to prefetch much more aggressively than they currently do, there is also a tangible risk of interference with training existing hardware prefetching mechanisms. Taken together, our observations suggest new research directions for cooperative hardware/software prefetching. Categories and Subject Descriptors: B.3.2 [Memory Structures]: Design Styles Cache memories; B.3.3 [Memory Structures]: Performance Analysis and Design Aids Simulation; D.3.4 [Programming Languages]: Processors Optimization General Terms: Experimentation, Performance Additional Key Words and Phrases: Prefetching, cache ACM Reference Format: Lee, J., Kim, H., and Vuduc, R When prefetching works, when it doesn t, and why. ACM Trans. Archit. Code Optim. 9, 1, Article 2 (March 2012), 29 pages. DOI = / INTRODUCTION Although a variety of software and hardware prefetching mechanisms for tolerating cache miss latency exist [Callahan et al. 1991; Perez et al. 2004; Vanderwiel and Lilja 2000], only relatively simple software prefetching algorithms have appeared in state-of-the-art compilers like icc [ICC] and gcc [GCC-4.0]. Therefore, performanceaware programmers often have to insert prefetching intrinsics manually [Intel 2011]. Unfortunately, this state of affairs is problematic for two reasons. First, there are few rigorous guidelines on how best to insert prefetch intrinsics. Secondly, the We gratefully acknowledge the support of the National Science Foundation (NSF) CCF , NSF/SRC task 1981, NSF CAREER award , NSF CAREER award ; the U.S. Department of Energy grant DESC ; Sandia National Laboratories; the Defense Advanced Research Projects Agency; Intel Corporation; Microsoft Research; and NVIDIA. Any opinions, findings and conclusions or recommendations expressed in this material are those of the authors and do not necessarily reflect those of NSF, SRC, DOE, DARPA, Microsoft, Intel, or NVIDIA. Author s address: H. Kim; Permission to make digital or hard copies of part or all of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies show this notice on the first page or initial screen of a display along with the full citation. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, to republish, to post on servers, to redistribute to lists, or to use any component of this work in other works requires prior specific permission and/or a fee. Permission may be requested from Publications Dept., ACM, Inc., 2 Penn Plaza, Suite 701, New York, NY , USA, fax +1 (212) , or c 2012 ACM /2012/03-ART2 $10.00 DOI /
2 2:2 J. Lee et al. Fig. 1. Summary of the software and hardware prefetching and their interactions. Benchmarks are sorted in decreasing order of the speedup of the best software+hardware prefetching (i.e., the best among SW, SW+GHB, and SW+STR) over the best performing hardware prefetching (i.e., the best among Base, GHB, and STR). complexity of the interaction between software and hardware prefetching is not well understood. In this study, we try to shed light on these issues. Our goal is to provide guidelines for inserting prefetch intrinsics in the presence of a hardware prefetcher and, more importantly, to identify promising new directions for automated cooperative software/hardware prefetching schemes. We summarize the complex interactions among software and hardware prefetching schemes in Figure 1. 1 Specifically, we show execution time (left y-axis) of the SPEC CPU 2006 benchmarks (x-axis) under a variety of software and hardware prefetching schemes. For each benchmark, we evaluate three binaries and three different simulated hardware prefetching schemes. All execution times are normalized to the execution time of the corresponding baseline binaries (Base 2 ) that have only compilerinserted software prefetchers without any hardware prefetching. 3 The GHB and STR bars (without the SW label) correspond to the baseline binaries running on two hardware configurations: a GHB hardware prefetcher [Nesbit and Smith 2004; Nesbit et al. 2004] and a stream-based prefetcher [Tendler et al. 2002], respectively. Lastly, the SW+... binaries include both compiler-inserted prefetches as well as our own manually inserted explicit software prefetch intrinsics. Observe first that baseline binaries do not provide any performance benefits over SW, because the compiler only conservatively inserts software prefetch instructions. To see the net effects and interactions among the prefetching schemes, we additionally calculate the speedup of the best software+hardware prefetching scheme (i.e., the best among SW, SW+GHB,andSW+STR) over the best performing hardware prefetching (i.e., the best among Base, GHB,andSTR). These speedups are shown as labeled horizontal dashes in Figure 1 (scale shown on the right y-axis). Based on these speedups, we group the benchmarks into three categories: positive, neutral, and negative. The milc, GemsFDTD, mcf, lbm, libquantum,andgcc benchmarks show performance improvements from software prefetching in excess of 5% (positive). By contrast, the sphinx3 and leslie3d benchmarks degrade performance more than 5% by using software prefetching (negative). We consider the remaining four benchmarks to exhibit neutral behavior. We can clearly see that the interactions among software and hardware prefetching yield a variety of benchmark-dependent performance behaviors. The goal of our study is to explore this interaction. 1 Here, we quickly preview these interactions, which Section 4 describes in greater detail. 2 The performance result of the baseline binaries are presented in Table V. 3 We use icc compilers as default, but we also present the results with gcc compilers in Section 5.3.
3 When Prefetching Works, When It Doesn t, and Why 2:3 Although others have studied the benefits and limitations of hardware and software prefetching [Emma et al. 2005; Perez et al. 2004; Vanderwiel and Lilja 2000], we are not aware of any study that explains why some benchmarks show positive/neutral/negative interactions from combined software and hardware prefetching with concrete examples from real benchmarks. We seek to provide such insights in this article by analyzing the source code, data structures, and algorithms used in applications. In particular, we seek answers to the following questions. (1) What are the limitations and overheads of software prefetching? (2) What are the limitations and overheads of hardware prefetching? (3) When is it beneficial to use software and/or hardware prefetching? Among our numerous findings, we show that when software prefetching targets short array streams, irregular memory address patterns, and L1 cache miss reduction, there is an overall positive impact with code examples. This observation is consistent with previous software prefetching work such as Intel s optimization guidelines [Intel 2011]. However, in this article we demonstrate these observations with actual code examples and empirical data. Furthermore, we also observe that software prefetching can interfere with the training of the hardware prefetcher, resulting in strong negative effects, especially when using software prefetch instructions for a part of streams. Our study aims to provide a deeper understanding of the interactions between software and hardware prefetching, focusing on schemes currently available in real systems, rather than proposing new schemes or evaluating various hardware/software prefetchers independently. Hence, our hardware prefetching schemes are limited to stream and stride prefetchers, since as far as we know these are the only two implemented commercially today. Similarly, the software prefetching schemes we consider use prefetch intrinsics on top of gcc or icc compiler-inserted prefetching. Furthermore, we also use both real systems (Intel s Core 2 [Intel 2007] and Nehalem [Intel 2009]) and simulations for our study. Simulations are used for more sophisticated experiments and real systems are used to confirm our findings. Although there are some discrepancies between simulations and real machines, most benchmarks show similar trends, especially for interactions between software and hardware prefetching. 2. BACKGROUND ON SOFTWARE AND HARDWARE PREFETCHING Table I summarizes commondata structures, their correspondingdata access patterns, and the hardware/software prefetching mechanisms previously proposed for each. The Hardware pref. column suggests possible hardware prefetching mechanisms that are suitable for the respective data structures. 4 The Software pref. column includes possible software prefetching mechanisms. In this study, we insert prefetch intrinsics not only for regular structures but also for some irregular data structures, such as Recursive Data Structures (RDS). As Table I indicates, array and some RDS data structure accesses can be easily predicted, and thereby prefetched, by software. However, data structures like hashing are much harder to prefetch effectively. Thus, several hardware and software prefetching mechanisms have been proposed to predict future cache miss addresses of complex data structures. Note that, in this article, we refer to unit-stride cache-line accesses as streams and access stride distances greater than two cache lines as strided. In our evaluation, we use stream prefetcher, GHB prefetcher, and content-based prefetcher as hardware-based prefetching mechanisms. 4 Note that there are other hardware prefetchers that aim generic data structures such as dead-block-based prefetching [Lai et al. 2001].
4 2:4 J. Lee et al. Table I. Data Structures and Corresponding Prefetching (a is the element to be prefetched, D is prefetch distance) Structure Code Pattern Size of a Index Hardware pref. Software pref. Array a[i] Stream < cache block direct stream [Jouppi 1990] a[i+d] Array a[i], a[i][const] Stride > cache block direct Array a[b[i]] irregular < cache block indirect RDS a=a next stride [Baer and Chen 1991] GHB [Nesbit and Smith 2004] content-directed (CDP) [Cooksey et al. 2002] markov [Joseph and Grunwald 1997] pointer cache [Collins et al. 2002] jump pointer [Roth and Sohi 1999] a[i+d][j] a[b[i+d]] stride [Wu 2002] CDP, markov a next next, irregular indirect pointer cache, jump pointer Luk-Mowry [Luk and Mowry 1996] Hash b[f(i)] a irregular indirect helper threads, Group Prefetching [Chen et al. 2007], pre-computation [Collins et al. 2001] SPAID [Lipasti et al. 1995] [Luk 2001; Zilles and Sohi 2001] Push-pull [Yang et al. 2004] no structure complex code regular/irregular helper threads, pre-computation Hint Table II. Different Prefetch Hints in Intrinsic Cache Insertion L1 L2 L3 Remarks MM HINT T0 (T0) O O O Temporal data with respect to all level caches MM HINT T1 (T1) X O O Temporal data with respect to first level cache MM HINT T2 (T2) X X O Temporal data with respect to second level cache MM HINT NTA (NTA) O X X Non-temporal data with respect to all level caches Table III. Prefetch Classifications Classification Accuracy Timeliness Timely accurate best prefetching Late accurate demand request arrives before prefetched block is serviced Early accurate demand request arrives after the block is evicted from a cache Redundant dc accurate the same cache block is in data cache Redundant mshr accurate the same cache block is in MSHR 5 Incorrect inaccurate block is never used even after the block is evicted from a cache 2.1 Software Prefetch Intrinsics When manually inserting prefetch requests, we use software prefetch intrinsics that are part of the x86 SSE SIMD extensions [Intel 2008, 2011]. An example of such an instrinsic for x86 systems is mm prefetch(char *ptr, int hint), which requires the programmer to specify both a prefetch address as well as a prefetch usage hint. Table II shows the possible hints. One intrinsic is roughly translated to two instructions for direct address prefetches or four instructions for indirect memory addresses. Section 2.4 explains this translation in detail. 2.2 Prefetch Classification We classify prefetch requests into the six categories listed in Table III. Figure 2 illustrates this classification on a timeline. For example, if a demand access occurs after its corresponding prefetch request but before it is inserted into the cache, we classify the prefetch as late. 2.3 Software Prefetch Distance Prefetching is useful only if prefetch requests are sent early enough to fully hide memory latency. The memory address of the cache block to be prefetched in an array data 5 Miss Status Holding Register [Kroft 1981].
5 When Prefetching Works, When It Doesn t, and Why 2:5 Fig. 2. Prefetch timeliness. Fig. 3. Assembly code of software prefetch intrinsic. structure is calculated by adding a constant value D to the array index. This value D is called the prefetch distance. We define prefetch distance as the distance ahead of which a prefetch should be requested on a memory address. The prefetch distance D for an array data structure a in Table I can be calculated as follows [Mowry et al. 1992]: l D (1) s where l is the prefetch latency and s is the length of the shortest path through the loop body. The average memory latency could vary at runtime and the average execution time of one loop iteration can also vary, so the prefetch distance should be chosen in such a way that it is large enough to hide the latency. However, if it is too large, prefetched data could evict useful cache blocks, and the elements in the beginning of the array may not be prefetched, leading to less coverage and more cache misses. Hence the prefetch distance has a significant effect on the overall performance of the prefetcher. We discuss the effect of software prefetch distance in greater detail in Section Direct and Indirect Memory Indexing There are two types of memory indexing, namely, direct and indirect. Typically, direct memory indexing can be easily prefetched by hardware since the memory addresses show regular stream/stride behavior, but indirect memory indexing requires special hardware prefetching mechanisms. On the contrary, indirect indexing is relatively simpler to compute in software. Thus, we expect software prefetching to be more effective than hardware prefetching for the indirect indexing case. Even though the address calculation is trivial in software, indirect prefetch requests still have a higher overhead than direct memory access. Figure 3 shows a simplified version of x86 instructions for direct/indirect prefetch requests for a[i]/a[b[i]]. In the case of direct memory indexing, only one prefetch load instruction, PREFETCH, is required other than memory index calculation. For indirect memory accesses, however, two loads are required. The first load is usually a regular load because the subsequent instruction is dependent on the first load instruction. Hence, prefetching an indirect memory index usually has a higher overhead than that of direct memory index. Note that the first load instruction can be prefetched. In that case, we need two levels of prefetch streams. 3. POSITIVE AND NEGATIVE IMPACTS OF SOFTWARE PREFETCHING In this section, we summarize the positive and negative impacts of software prefetching compared to hardware prefetching, as well as both the synergistic and antagonistic effects between the two.
6 2:6 J. Lee et al. 3.1 Benefits of Software Prefetching over Hardware Prefetching Large Number of Streams (Limited Hardware Resources). The number of streams in the stream prefetcher is limited by hardware resources, such as stream detectors and book-keeping mechanisms. For instance, Intel Pentium-M and Core 2 can issue 8 and 16 stream prefetches, respectively [Intel 2004, 2007]. Unfortunately, in some benchmarks, the number of streams exceeds the hardware s capacity, especially in the case of scientific computing workloads that have multiple streams. For example, lbm, a stencil-based computation, a 3D grid data structure and loop references all 27 nearest neighbors for each grid point (b[i][ j][k] =(a[i][ j][k]+a[i][ j][k +1]+a[i][ j][k 1] + a[i][ j 1][k]+a[i][ j +1][k]+...)/27). Software prefetching can insert prefetch requests independently for each stream in lbm, whereas it is difficult for hardware prefetchers that are typically easily confused when there are too many streams Short Streams. Hardware prefetchers require training time to detect the direction and distance of a stream or stride. Even aggressive hardware prefetchers require at least two cache misses to detect the direction of stream. If the length of stream is extremely short, there will not be enough cache misses to train a hardware prefetcher and load useful cache blocks. For example, milc exhibits short stream behavior. In particular, it operates on many 3x3 matrices using 16 bytes per element, so the total size of the matrix is 144 bytes, or just three cache blocks. 6 Therefore, these streams are too short to train the hardware prefetchers. Although there is a new hardware-based prefetching specifically for short streams [Hur and Lin 2006, 2009], no commercial systems presently use it Irregular Memory Access. As shown in Table I, we can typically prefetch various kinds of irregular data structures by inserting appropriate prefetch intrinsics, in contrast to hardware prefetchers, which usually require very complex structures. An RDS example from our benchmark suite is the mcf benchmark Cache Locality Hint. Hardware prefetchers in today s high-performance processors such as Nehalem [Intel 2009] and Barcelona [AMD] place the data in the lowerlevel cache of the requesting core, whereas most software prefetched data is placed directly into the L1 cache. Lower-level (L2 or L3) prefetching block insertion greatly reduces the higher level (L1) cache pollution, but L2 to L1 latency can degrade performance significantly. In the software prefetching mechanism, there is greater flexibility of placing data in the right cache level. In particular, there is a prefetch hint (Table II) associated with every prefetch request. Current hardware prefetchers either have to apply the same cache insertion policy or they require complex hardware mechanisms to differentiate between the individual prefetches to place data in a smart manner Loop Bounds. We can determine loop bounds in array data structures in software with little or no effort. Several methods prevent generating prefetch requests out of array bounds in software such as loop unrolling, software pipelining, and using branch instructions [Chen and Baer 1994; Vanderwiel and Lilja 2000]. The same is not possible in hardware, especially when the hardware prefetcher is aggressive (large prefetch distance and high prefetch degree). However, overly aggressive prefetching results in early or incorrect prefetch requests, in addition to consuming memory bandwidth. 6 The cache block size is 64B in our all evaluations.
7 When Prefetching Works, When It Doesn t, and Why 2:7 Fig. 4. Instruction count increase. 3.2 Negative Impacts of Software Prefetching (1) Increased Instruction Count. Unlike hardware prefetching, software prefetch instructions consume fetch and execution bandwidth and machine resources, as Figure 4 suggests. For example, the number of instructions in bwaves increases by more than 100% due to software prefetches. (2) Static Insertion. The programmer or the compiler determines the data to be prefetched and the corresponding prefetch distance. The decision to prefetch and choice of these parameters are made statically, and therefore cannot adapt to runtime behavioral changes such as varying memory latency, effective cache size, and bandwidth, especially in heterogeneous architectures. Adaptivity is important because it is well-known that the pattern of memory addresses can exhibit phase behavior [Zhang et al. 2006]. In hardware, prefetch distance and prefetching degree are usually fixed as well, although there are some recently proposed feedbackdriven adaptive hardware prefetching mechanisms [Ebrahimi et al. 2009; Srinath et al. 2007]. In software, adaptive mechanisms are largely nonexistent. (3) Code Structure Change. When the number of instructions in a loop is extremely small, it can be challenging to insert software prefetching instructions to provide timely prefetching requests because there are not enough computations between prefetching instructions and demand requests. Therefore, code structure changes, such as loop splitting, are required. For some cases, because of excessive increases in the number of instructions, inserting software prefetching becomes difficult. 3.3 Synergistic Effects when Using Software and Hardware Prefetching Together (1) Handling Multiple Streams. Using software and hardware prefetching together can help cover more data streams. For example, a hardware prefetcher might cover regular streams and software prefetching can cover irregular streams. (2) Positive Training. Software prefetch requests can actually help train the hardware prefetcher. If a block prefetched by a software prefetcher is late, then a trained hardware prefetcher can improve prefetch timeliness. 3.4 Antagonistic Effects when Using Software and Hardware Prefetching Together (1) Negative Training. Software prefetch requests can slow down the hardware prefetcher training. If prefetched blocks by software prefetching hide a part of one or more streams, the hardware prefetcher will not be trained properly. Also, software prefetch instructions can trigger overly aggressive hardware prefetches, which results in early requests. Section shows negative training examples in milc and libquantum. (2) Harmful Software Prefetching. Hardware prefetchers generally have a lower accuracy than software prefetchers. When software prefetch requests are incorrect or
8 2:8 J. Lee et al. early, the increased stress on cache and memory bandwidth can further reduce the effectiveness of hardware prefetching. 4. EXPERIMENTAL METHODOLOGY Given the preceding background on the anticipated effects of and interactions between hardware and software prefetching, the goal of our study is to quantitatively explore these interactions. Our experimental setup is as follows. 4.1 Prefetch Intrinsic Insertion Algorithm We are interested in the maximum potential of software prefetching. To assess the potential, we insert additional software prefetch intrinsics based on the following methodology. First, we profile each application to identify prefetch candidates. A prefetch candidate is any load whose L1 misses per thousand instructions (MPKI) exceeds Then, for each candidate, we insert a software prefetch. To make our choice of prefetch distance systematic, we compute it as Distance = K L IPC bench, (2) W loop where K is a constant factor, L is an average memory latency, IPC bench is the profiled average IPC of each benchmark, and W loop is the average instruction count in one loop iteration. We use K =4andL = 300 for all benchmarks. Importantly, we determine IPC bench and W loop from the profile data, so that the choice of distance is effectively profile-driven. The sensitivity of performance to the prefetch distance is presented in Section The default prefetch hint is T0 and the remaining hints are evaluated in Section The preceding scheme applies to regular loads. For loads on complex data structures, such as RDS, hash, C++ overloaded operators, and short functions without any loops, we do not use these prefetch intrinsics. 4.2 Simulation Methodology We use MacSim 8, a trace-driven and cycle-level simulator, to evaluate software and hardware prefetching effects. We faithfully model all components in the memory system. Table IV shows the processor configurations used in our experiments. We perform experiments on 13 memory-intensive benchmarks from SPEC CPU We chose benchmarks that achieve at least 100% performance gain with a perfect memory system, that is, one in which all memory accesses hit in the L1 cache. However, we also excluded four additional benchmarks that meet this definition of memory intensive omnetpp, astar, xalancbmk, andwrf because we were not able to insert any software prefetch intrinsics. We use Pinpoints [Patil et al. 2004] to select a representative simulation region for each benchmark using the reference input set. Each benchmark is run for roughly 200M x86 instructions. 9 Since different binaries have different numbers of instructions, we ensure that the number of function calls is the same, so that we simulate the same section of the code across different binaries. 7 We chose 0.05 through experimentation. The sensitivity results are not included due to the space limitations Due to extra software prefetching instructions, the SW binaries have more than 200M instructions.
9 When Prefetching Works, When It Doesn t, and Why 2:9 Table IV. Processor Configurations (base:baseline, less: less aggressive, agg: more aggressive) less 2-wide 10-stage Pipeline, 36-entry ROB, 1GHz in-order Execution Core base 4-wide 15-stage Pipeline, 256-entry ROB, 2GHz out-of-order agg 6-wide 18-stage Pipeline, 1024-entry ROB, 4GHz out-of-order less I-cache: 16KB, 4-way, 2-cycle, 2/2 write/read ports Front-end base I-cache: 32KB, 4-way, 3-cycle, 4/4 write/read ports agg I-cache: 64KB, 4-way, 4-cycle, 6/6 write/read ports less L1 D-cache: 16KB, 4-way, 2-cycle, 2/2 write/read ports L2 Unified-cache: 128KB, 8-way, 6-cycle, 1/1 write/read port, 32 MSHRs On-chip Caches base L1 D-cache: 32KB, 4-way, 3-cycle, 4/4 write/read ports L2 Unified-cache: 1MB, 8-way, 10-cycle, 1/1 write/read port, 128 MSHRs agg L1 D-cache: 64KB, 4-way, 4-cycle, 6/6 write/read port L2 Unified-cache: 8MB, 8-way, 14-cycle, 1/1 write/read port, 256 MSHRs LRU replacement, 64B line less DDR2-533, 3-3-3, Bandwidth 2.1GB/s Buses and Memory base DDR2 800, 6-6-6, Bandwidth 6.4GB/s agg DDR3-1600, 9-9-9, Bandwidth 25.6GB/s Stream Prefetcher [Tendler et al. 2002; Srinath et al. 2007] 16 streams, Prefetch Degree 2, Prefetch Dist. 16 GHB Prefetcher [Nesbit and Smith 2004; Nesbit et al. 2004] 1024 entries, Prefetch Degree 16 Table V. Characteristics of the Simulated Benchmarks BASE SW Lang/Type #Inst. L1 MPKI L2 MPKI Base IPC PerfMem IPC (%) #Inst. Static # Pref. Dyn. # Pref. bzip2 c/int 203M M M gcc c/int 207M M M bwaves F/fp 202M M M mcf c/int 200M M milc c/fp 210M M M zeusmp F/fp 216M M M cactusadm FPP/fp 201M M M leslie3d F/fp 203M M M soplex c++/fp 257M M M GemsFDTD F90PP/fp 216M M M libquantum c/int 200M M M lbm c/fp 200M M M sphinx3 c/fp 201M M M PerfMem: the performance of benchmarks with zero-cycle memory latency Static Pref and Dynamic Pref: the number of prefetch instructions that are inserted by a programmer Table V shows the characteristics of the evaluated benchmarks (Base binaries) on the baseline processor. The remaining SPEC CPU 2006 benchmarks are presented in Table VI. All benchmarks are compiled using icc and ifort Results for the GCC compiler appear in Section EVALUATIONS: BASIC OBSERVATIONS ABOUT PREFETCHING We first make a number of basic observations about software and hardware prefetching and their interactions. Our goal is to evaluate the hypotheses outlined in Section 3. Note that we consider a variety of factors; for a quick summary of the key findings, refer to Section Overhead and Limitations of Software Prefetching Instruction Overhead. Instruction overhead is among the major negative impacts of software prefetching (Section 3.2). Figure 4 shows how the instruction count
10 2:10 J. Lee et al. Table VI. Characteristics of the Remaining SPEC CPU 2006 Benchmarks Bench perlbench gobmk hmmer sjeng h264ref omnetpp astar xalancbmk Lang/Type c/int c/int c/int c/int c/int c++/int c++/int c++/int Base IPC PerfMem (%) Bench gamess gromacs namd dealii povray calculix tonto wrf Lang/Type FPP/fp c/fp c++/fp c++/fp c++/fp F/fp F90PP/fp F90PP/fp Base IPC PerfMem (%) Fig. 5. Ideal experiments (SW+P: no pollution, SW+B: no bandwidth, SW+L: no latency, SW+R: eliminate redundant prefetch overhead, SW+I: eliminate inst. overhead). increases in SW binaries. For GemsFDTD, bwaves, andleslie3d, the total number of instructions increases by more than 50% (more than 100% for bwaves). These extra instructions come not just from prefetch instructions but also from regular instructions due to handling of indirect memory accesses and index calculations. Surprisingly, although GemsFDTD increases instructions by more than 50%, it is still in the positive (improved performance) group because the benefits outweigh this instruction overhead Software Prefetching Overhead. To measure the overhead of software prefetching, we eliminate the overhead of cache pollution (SW+P), bandwidth consumption (SW+B,between core and memory), memory access latency (SW+L), redundant prefetch overhead (SW+R), and instruction overhead (SW+I). Figure 5 summarizes the results. Cache pollution would be caused by early or incorrect prefetches. However, there are not many of either in our experiments. Thus, the effects of cache pollution are small, as shown by the relatively small values of SW+P in essentially all cases. Similarly, the mostly small values of SW+B show that current machines provide enough bandwidth for single-thread applications. The mostly larger values of SW+L shows that software prefetching is not completely hiding memory latency. The values of SW+R show that, surprisingly, the negative effect of redundant prefetch instructions is generally negligible even though a huge number of redundant prefetches exist. Finally, SW+I experiments show that even though the number of instructions increased significantly for GemsFDTD, bwaves, andleslie3d (see Section 5.1.1), their actual time overhead is not high The Effect of Prefetch Distance. Figure 6 shows the sensitivity of performance to prefetch distance. The x-axis show the prefetch distance relative to the base prefetch distance. The base prefetch distance is calculated using Equation (1). The unit of prefetch distance is a cache block.
11 When Prefetching Works, When It Doesn t, and Why 2:11 Fig. 6. Performance variations by the prefetch distance. Table VII. Categorization of Benchmark Groups by the Distance Sensitivity Group Optimal Zone Perf. Delta Benchmarks A narrow high GemsFDTD, lbm, milc B narrow low cactusadm C wide high bwaves D wide low mcf E insensitive soplex, sphinx3, libquantum, gcc, bzip2, leslie3d, zeusmp Based on the shape of the optimal distance zone and the performance variance, we categorize all benchmarks into five groups. Table VII shows all groups and their descriptions. Figure 6 shows the performance variations from each group. Most benchmarks from the neutral and negative groups in Figure 1 are insensitive to the prefetch distance (Group E). The two exceptions are cactusadm and bwaves. These benchmarks reach the optimal distance from the beginning ( 4 in Figure 6) and have wider optimal distance zones Static Distance vs. Machine Configuration. One limitation of using static prefetch distances is that the optimal distance might vary by machine. This effect will be exacerbated in future heterogeneous multicore systems, since the programmer is likely not to know the core/system configuration in advance. To understand the sensitivity of optimal prefetch distance to machine configuration, we compare the best performing static distance for three different machine configurations (base, less-aggressive, and aggressive processors in Table IV). The left three figures in Figure 7 show the performance for the best prefetch distance for each machine configuration. The right three figures in Figure 7 show the performance difference between the the best distance in the baseline and the best distance for each machine s configuration. For example, the best distances for lbm are 2, 0, and 8 for less-aggressive, base, and aggressive processors, respectively. We measure the performance difference between that of distance 2 and 0 in the less-aggressive processor and the difference between that of distance 8 and 0 in the aggressive processor. Despite the variations in the optimal distance, the performance difference is generally not high except for lbm. This observation is not surprising given that most benchmarks are classified as Group E (insensitive) in Table VII. As for lbm, we analyze it in more detail in Section We conclude that the static prefetch distance variance does not impact performance significantly even if the machine configuration is changed at runtime Cache-Level Insertion Policy. In general, an out-of-order processor can easily tolerate L1 misses, so hardware prefetchers usually insert prefetched blocks into the last level cache to reduce the chance of polluting the L1 cache. However, when the L1 cache
12 2:12 J. Lee et al. Fig. 7. Best performing distance variances with different core specifications. Fig. 8. Different prefetch hint results. miss rate is higher than what a processor can tolerate, even an L1 cache miss can degrade performance. Since software prefetching is generally accurate, we can safely insert prefetched blocks into the L1 cache directly without the risk of polluting the L1 cache. In all our experiments, we use the T0 cache-level placement hint, as shown in Table II. Note that T1 and T2 behave the same in our two-level cache hierarchy. Figure 8 shows performance results when varying the hint (level). The benefit of T0 over T1 (T2) mainly comes from hiding L1 cache misses by inserting prefetched blocks into the L1 cache. In the evaluated benchmarks, libquantum represents this behavior. With software prefetching, the L1 cache miss rate is reduced from 10.4% to 0.01% (Figure 26), which results in a significant performance improvement. Where we might expect the T1 and T2 hints to work well is in the case of streaming applications that have little data reuse. Since our benchmarks do not have such applications, we find that T0 always performs better than other hints in all evaluated benchmarks.
13 When Prefetching Works, When It Doesn t, and Why 2:13 Fig. 9. Hardware prefetcher trained by software prefetch requests. 5.2 Effect of Using Hardware and Software Prefetching Together Hardware Prefetcher Training Effects. To evaluate how software and hardware prefetching interact with each other, we consider two different hardware prefetcher training policies. (1) NT (SW+GHB, SW+STR). The hardware prefetcher s training algorithm ignores software prefetch requests. That is, the hardware prefetcher is only trained by demand cache misses. (2) Train (SW+GHB+T, SW+STR+T). The hardware prefetcher s training algorithm includes software prefetch requests, in addition to the usual demand misses. Figure 9 shows the performance improvement of the Train policy over NT for both GHB and STR. For both GHB and STR, the sphinx3 benchmark shows a small benefit from training with software prefetches. By contrast, milc, gcc, andsoplex exhibit negative effects for both GHB and STR. The mcf and bwaves benchmarks are largely unaffected by training policy. For the remaining benchmarks, the effect of the training policy is prefetcher-specific, for instance, positive with GHB and negative with STR. The benefit could be up to 3 5% and these benefits come from training hardware prefetching early, that is, by reducing late prefetching. However, the negative impact can be severe: 55.9% for libquantum, and 22.5% for milc. Themilc benchmark has short streams, so software prefetching can trigger unnecessary hardware prefetches. There are two reasons for the performance degradation in libquantum. The first reason is because of severe L1 miss penalties. Software prefetches are mainly inserted into the L1 and L2 caches. However, if hardware prefetching is trained by this software prefetching, prefetched blocks are inserted into only L2 rather than L1, thereby reducing the L1 prefetching benefits. The second reason is overly aggressive prefetches. To provide timeliness, software and hardware prefetches have prefetch distances independently. However, when software prefetch instructions train a hardware prefetcher, then hardware prefetch requests can be too aggressive (on top of software prefetch distance, now hardware prefetching adds its own prefetch distance), resulting in many early prefetches. From these experiments, we can conclude that the negative impact can reduce performance degradation significantly. Thus, although there are some positive benefits, it is generally better not to train hardware prefetching with software prefetching requests Prefetch Coverage. We consider the prefetch coverage or, the ratio of useful prefetches to total L2 misses in Figure 10(a), for GHB and STR. Figure 10(b) shows the prefetch coverage of SW+GHB and SW+STR. Additional useful hardware prefetches are indicated as HW and are shown on top of the SW bars. Generally, the coverage of software prefetching is higher than that of hardware prefetchers, but the software coverage of benchmarks in that neutral and negative
14 2:14 J. Lee et al. Fig. 10. Prefetch coverage. Fig. 11. Software prefetch classifications (G:SW+GHB, S:SW+STR, GT:SW+GHB+T, ST:SW+STR+T). groups is lower than that of the hardware prefetchers. Thus, we can conclude that less coverage is the main reason for performance loss in the neutral and negative groups Prefetching Classification. Foreachbenchmark,weclassifytheprefetchesintothe categories of timely, late, early, etc., as summarized in Table III. Figure 11 summarizes the results. Only bzip2 and soplex show more than 10% early prefetches. A prefetch cache could mitigate the cache pollution effect. For mcf, 10% of prefetches are late, due to a dependent load instruction that the prefetch intrinsic generates. By eliminating the latency overhead (Figure 5 SW+L case), the performance of mcf is improved by 9%. Surprisingly, even though a significant number of redundant prefetches exists in many benchmarks, there is little negative effect on the performance (Figure 5 SW+R case). 5.3 Using the GCC Compiler Except in this section, we use the icc compiler for our evaluation because gcc (more specifically gfortran) does not support intrinsics in Fortran. To understand the gcc compiler s effect, we insert intrinisics after compiling the code with gcc in these experiments. The simulated regions are exactly the same as those of icc, butweexclude all Fortran benchmarks since the gfortran compiler does not support prefetch intrinsics. We use gcc 4.4 in our evaluations.
15 When Prefetching Works, When It Doesn t, and Why 2:15 Fig. 12. Baseline experiments with gcc compiler. Fig. 13. Instruction counts with gcc compiler. Machine Nehalem Core 2 Table VIII. Specification of Two Intel Processors Specification Dual Intel Xeon E5520 (2.27GHz, 8MB L3 Cache, SMT Disabled), 24GB DDR3 Memory Dual Intel Xeon E5420 (2.50GHz, 12MB L2 Cache), 8GB DDR2 Memory We summarize the results of the gcc compiler experiments in Figure 12. Figure 13 shows the number of prefetch instructions in each binary. The gcc compiler inserts more software prefetches than icc, except for mcf and lbm. Recall that icc does not insert any prefetch instructions. However, gcc still cannot cover all cache misses. Thus, the performance of the Base binaries compiled with gcc lies between the performance of NOSW (prefetch flag is disabled) and SW, whereas that of icc is the same as NOSW. 5.4 Real System Experiments In addition to the simulation results, we also measured the effect of software prefetching on two recent Intel processors, Core 2 and Nehalem. Table VIII summarizes the specifications of these processors. In our real systems experiments, we run the entire reference input sets, not just the simpointed section. 10 Table IX shows that both simulated regions and the entire execution have a similar portion of prefetch instructions. Except for milc, gcc,andzeusmp, the simulated region of other benchmarks accurately represents the entire code. Note that our simulated system is closer in its configuration to the Core 2. Figure 14 shows results. In real system experiments, we also see that software prefetching reduced the performance of cactusadm, soplex, bwaves, sphinx3, and 10 This is one of the reasons the simulated and measured performance differ.
16 2:16 J. Lee et al. Table IX. Comparison between entire and simulated codes. Total ratio is #prefetch inst/#total inst and Sim ratio is the fraction in the simulated regions Benchmark Total (Mem) Inst. Total ratio Sim ratio Benchmark Total (Mem) Inst. Total ratio Sim ratio milc 1.66T (728B) 0.48% 2.40% GemsFDTD 1.69T (860B) 5.06% 7.32% mcf 906B (463B) 2.24% 2.19% lbm 1.45T (609B) 5.1% 5.27% libquantum 2.41T (799B) 10.7% 8.9% gcc 157B (81B) 0.02% 1.48% zeusmp 1.94T (675B) 0.38% 4.68% bzip2 583B (267B) 1.8% 2.26% cactusadm 2.78T (1.6T) 4.45% 4.36% soplex 1.73T (972B) 2.2% 2.2% bwaves 2.59T (1.8T) 14% 16.26% sphinx3 4.34T (1.73T) 11.8% 11.97% leslie3d 2.14T (1.1T) 10.74% 11.71% Fig. 14. Real system experiment results. leslie3d by a small amount in the real system measurements, even though it always shows benefits in our simulations. However, all benchmarks in the positive group also show benefits from using software prefetches. Compared with the Core 2, the hardware prefetchers of Nehalem have improved. Also, due to the multiple cache levels of prefetchers in Nehalem (L3 to L2 and L2 to L1), the benefits of software prefetching are reduced (In Section 3.1.4, we discussed the software prefetching benefits of inserting prefetched blocks directly into the L1 cache). 5.5 Profile-Guided Optimization (PGO) We also examine the effect of profile-guided optimization. Note that we perform experiments using both icc and gcc, but we do not include the results from icc because it does not insert any software prefetches. We use gcc 4.4 with fprofile-generate and fprofile-use flags. Figure 15 shows the results of PGO. Generally, the performance of using PGO lies between that of Base and SW. However, performance benefits come from other optimizations, not only software prefetching. Figure 15(c) and (d) show the number of total and prefetch instructions. The number of prefetch instructions are rather decreased in the PGO-compiled binaries. Also, the instruction count of the PGO binaries is less than that of the Base binaries in all cases. 5.6 Hardware Prefetcher for Short Streams One weakness of hardware prefetching is the difficulty of exploiting short streams. To tackle this problem, some have proposed the so-called ASD hardware prefetcher [Hur and Lin 2006, 2009]. (ASD is currently an idea with no known implementations, as far as we know.) We evaluate ASD along with software and hardware prefetching, with the results summarized in Figure 16.
17 When Prefetching Works, When It Doesn t, and Why 2:17 Fig. 15. Profile-guided optimization results. Fig. 16. ASD hardware prefetcher results. The milc benchmark exhibits short stream behavior. On average, ASD provides a 7% performance benefit on milc without software prefetching. However, software prefetching itself can still provide more than a 2x speedup. Although ASD can predict short-length streams, it still requires observing the first instances of a memory stream. ASD provides benefits over the other two evaluated hardware prefetchers, but the overall benefit is less than 3%. The gcc, sph, andles benchmarks perform better than the baseline when combining ASD, software prefetching, and GHB/STR hardware prefetching, but only by 2% or less. Thus, we conclude that software prefetching is much more effective for prefetching short streams than ASD. 5.7 Content Directed Prefetching We also evaluated content directed prefetching (CDP) schemes, which target linked and other irregular data structures [Al-Sukhni et al. 2003; Cooksey et al. 2002; Ebrahimi et al. 2009]. Figure 17 shows results. We focus on gcc and mcf results since
18 2:18 J. Lee et al. Fig. 17. CDP hardware prefetcher results. Fig. 18. Manual optimization results. these are the only two benchmarks affected, positively or negatively, by CDP. CDP provides 3.9% and 6.5% improvement on mcf and gcc, respectively. We also evaluate CDP with a separate prefetch cache (CDP+PF), which prevents cache pollution, a well-known limitation of CDP. We find additional 2% and 5% benefits. However, when compared with software prefetching s 78% improvement, we conclude that software prefetching is more effective for irregular data structures. 5.8 Manual Tuning Since we used the prefetch intrinsic insertion algorithm in Section 4.1 for all benchmarks, we cannot be sure that software prefetching is being used to its full potential. Thus, we also manually and exhaustively tune the benchmarks. In particular, we remove useless prefetches, adjust the prefetch distance of each software prefetch, and apply additional overhead-reduction techniques, such as loop unrolling and prologue/epilogue transformations for each benchmark. We exclude milc, GemsFDTD, lbm, bwaves, andbzip2 because they either are already highly optimized or require significant code structure changes. Figure 18 shows the manual tuning results, where MAN indicates our manually tuned binaries. The speedup shown is for MAN over SW. We vary the distance of all prefetch intrinsics individually and select the distance for each prefetch intrinsic that yields the best performance. The speedup in the neutral and negative groups is much higher than the speedup in the positive group, which implies that it is more effective to remove negative intrinsics manually. However, there are no significant performance changes between manual tuning and the algorithm in Section 4.1, especially in the positive group, which shows that the algorithm is good to use as a guideline for inserting software prefetch intrinisics.
19 When Prefetching Works, When It Doesn t, and Why 2:19 Table X. Prefetching Summary of Benchmark Group Benchmark Data structure GHB+T STR+T Why SW is better Why SW is worse Best 433.milc short array short array SW+GHB 459.GemsFDTD indirect, stride = + indirect access SW+STR+T 429.mcf RDS, AoP = = irregular (AoP) SW+STR POS 470.lbm stride = = reduction in L1 misses SW+STR+T 462.libquantum stride = reduction in L1 misses SW+STR+T 403.gcc RDS, indirect - indirect access SW+STR 434.zeusmp stride + - reduction in L1 misses SW+GHB+T 434.bzip2 indirect, hash + + SW+GHB+T NEU 436.cactusADM stride + - SW+GHB+T 436.soplex indirect - - STR 410.bwaves stream = = STR NEG 482.sphinx3 stride + + loop is too short SW+STR 437.leslie3d stream - - loop is too short SW+STR +: positive, -: negative, Best: best performing case among all evaluated cases 5.9 Summary of New Findings Though there are numerous results, here we summarize our key findings. (1) Hardware prefetchers can under-exploit even regular access patterns, such as streams. Short streams are particularly problematic, and software prefetching is frequently more effective in such cases. (2) The software prefetching distance is relatively insensitive to the hardware configuration. The prefetch distance does need to be set carefully, but as long as the prefetch distance is greater than the minimum distance, most applications will not be sensitive to the prefetch distance. (3) Although most L1 cache misses can be tolerated through out-of-order execution, when the L1 cache miss rate is much higher than 20%, reducing L1 cache misses by prefetching into the L1 cache can be effective. (4) The overhead of useless prefetching instructions is not very significant. Most applications that have prefetching instructions are typically limited by memory operations. Thus, having some extra instructions (software prefetching instructions) does not increase execution time by much. (5) Software prefetching can be used to train a hardware prefetcher and thereby yield some performance improvement. However, it can also degrade performance severely, and therefore must be done judiciously if at all. 6. CASE STUDIES: SOURCE CODE ANALYSIS OF INDIVIDUAL BENCHMARKS In this section, we explain the reasons for the observed software prefetching behaviors using source code analysis. The key observed behaviors appear in Table X. 6.1 Positive Group milc. Most cache misses in milc occur during accesses to small arrays, in such functions as mult su3 na, which is shown in Figure 19. These functions operate on 3x3 matrices. As discussed in Section 3.1.2, these matrix accesses correspond to short streams, which are too short to train the hardware prefetchers. By contrast, software prefetching can effectively prefetch these arrays, provided the prefetch requests are inserted appropriately near the call site. When doing so, we observe a 2.3x speedup compared with the best hardware-only prefetching scheme. Figure 20 shows the number of L2 cache misses for Base, GHB, STR, andsw binaries from the eight source code lines that generate the most cache misses in Base. Since
20 2:20 J. Lee et al. Fig. 19. Code example:433.milc. Fig. 20. L2 cache misses in 433.milc. the Base and SW binaries have different PC addresses, we match each individual PC address with the source line. As expected, hardware prefetchers do not reduce cache misses, whereas software prefetching can eliminate almost all misses. Since software prefetching can cover all misses, training the hardware prefetchers will increase memory traffic with useless prefetches, thereby increasing the execution time by 15% and 23% with GHB and stream prefetcher, respectively GemsFDTD. Most delinquent loads in GemsFDTD come from complex indirect memory accesses. For instance, consider Figure 21. The variable m is used as an (indirect) index. Since this indirect indexing is very irregular from the hardware perspective, the hardware prefetchers do not prove to be very useful, improving performance by only 12% improvement (stream prefetcher). On the contrary, this complex indirect indexing can be handled very effectively in software prefetching. Doing so results in more than a 50% execution time reduction compared with Base mcf. The mcf benchmark is well-known as a memory intensive benchmark due to its pointer chasing behavior. It also uses an array of pointers (AoP) data structure. Since AoP exhibits irregular behavior, hardware prefetchers typically do not perform well on such structures. However, the arc structure can be prefetched in software, as shown in Figure 22. A suitable software prefetch can calculate the next address by using the next array index, whereas neither GHB nor stream prefetchers can prefetch them. SW+STR provides a 180% improvement over STR. The stream prefetcher
Achieving QoS in Server Virtualization
Achieving QoS in Server Virtualization Intel Platform Shared Resource Monitoring/Control in Xen Chao Peng (email@example.com) 1 Increasing QoS demand in Server Virtualization Data center & Cloud infrastructureMore information
Analysis of Memory Sensitive SPEC CPU2006 Integer Benchmarks for Big Data Benchmarking
Analysis of Memory Sensitive SPEC CPU2006 Integer Benchmarks for Big Data Benchmarking Kathlene Hurt and Eugene John Department of Electrical and Computer Engineering University of Texas at San AntonioMore information
An OS-oriented performance monitoring tool for multicore systems
An OS-oriented performance monitoring tool for multicore systems J.C. Sáez, J. Casas, A. Serrano, R. Rodríguez-Rodríguez, F. Castro, D. Chaver, M. Prieto-Matias Department of Computer Architecture ComplutenseMore information
How Much Power Oversubscription is Safe and Allowed in Data Centers?
How Much Power Oversubscription is Safe and Allowed in Data Centers? Xing Fu 1,2, Xiaorui Wang 1,2, Charles Lefurgy 3 1 EECS @ University of Tennessee, Knoxville 2 ECE @ The Ohio State University 3 IBMMore information
Virtualisierung im HPC-Kontext - Werkstattbericht
Center for Information Services and High Performance Computing (ZIH) Virtualisierung im HPC-Kontext - Werkstattbericht ZKI Tagung AK Supercomputing 19. Oktober 2015 Ulf Markwardt +49 351-463 33640 email@example.com information
Comparison of Processor Performance of SPECint2006 Benchmarks of some Intel Xeon Processors
Comparison of Processor Performance of SPECint2006 Benchmarks of some Intel Xeon Processors Abdul Kareem PARCHUR * and Ram Asaray SINGH Department of Physics and Electronics, Dr. H. S. Gour University,More information
Computer Architecture
Computer Architecture Slide Sets WS 2013/2014 Prof. Dr. Uwe Brinkschulte M.Sc. Benjamin Betting Part 6 Fundamentals in Performance Evaluation Computer Architecture Part 6 page 1 of 22 Prof. Dr. Uwe Brinkschulte,More information
Performance Characterization of SPEC CPU2006 Integer Benchmarks on x86-64 64 Architecture
Performance Characterization of SPEC CPU2006 Integer Benchmarks on x86-64 64 Architecture Dong Ye David Kaeli Northeastern University Joydeep Ray Christophe Harle AMD Inc. IISWC 2006 1 Outline MotivationMore information
Combining Local and Global History for High Performance Data Prefetching
Journal of Instruction-Level Parallelism 13 (2011) 1-14 Submitted 3/10; published 1/11 Combining Local and Global History for High Performance Data Prefetching Martin Dimitrov Department of ElectricalMore information
Running Virtual Machines in a Slurm Batch System
Center for Information Services and High Performance Computing (ZIH) Running Virtual Machines in a Slurm Batch System Slurm User Group Meeting September 2015 Ulf Markwardt +49 351-463 33640 firstname.lastname@example.com information
Schedulability Analysis for Memory Bandwidth Regulated Multicore Real-Time Systems
Schedulability for Memory Bandwidth Regulated Multicore Real-Time Systems Gang Yao, Heechul Yun, Zheng Pei Wu, Rodolfo Pellizzoni, Marco Caccamo, Lui Sha University of Illinois at Urbana-Champaign, USA.More information
Compiler-Assisted Binary Parsing
Compiler-Assisted Binary Parsing Tugrul Ince firstname.lastname@example.com PD Week 2012 26 27 March 2012 Parsing Binary Files Binary analysis is common for o Performance modeling o Computer security o MaintenanceMore information
Reducing Dynamic Compilation Latency
LLVM 12 - European Conference, London Reducing Dynamic Compilation Latency Igor Böhm Processor Automated Synthesis by iterative Analysis The University of Edinburgh LLVM 12 - European Conference, LondonMore information
Performance Impacts of Non-blocking Caches in Out-of-order Processors
Performance Impacts of Non-blocking Caches in Out-of-order Processors Sheng Li; Ke Chen; Jay B. Brockman; Norman P. Jouppi HP Laboratories HPL-2011-65 Keyword(s): Non-blocking cache; MSHR; Out-of-orderMore information
Prefetch-Aware Shared-Resource Management for Multi-Core Systems
Prefetch-Aware Shared-Resource Management for Multi-Core Systems Eiman Ebrahimi Chang Joo Lee Onur Mutlu Yale N. Patt HPS Research Group The University of Texas at Austin {ebrahimi, email@example.com information
Parallel Computing 37 (2011) 26 41. Contents lists available at ScienceDirect. Parallel Computing. journal homepage: www.elsevier.
Parallel Computing 37 (2011) 26 41 Contents lists available at ScienceDirect Parallel Computing journal homepage: www.elsevier.com/locate/parco Architectural support for thread communications in multi-coreMore information
Addressing Shared Resource Contention in Multicore Processors via Scheduling
Addressing Shared Resource Contention in Multicore Processors via Scheduling Sergey Zhuravlev Sergey Blagodurov Alexandra Fedorova School of Computing Science, Simon Fraser University, Vancouver, CanadaMore information
Program Optimization Study on a 128-Core GPU
Program Optimization Study on a 128-Core GPU Shane Ryoo, Christopher I. Rodrigues, Sam S. Stone, Sara S. Baghsorkhi, Sain-Zee Ueng, and Wen-mei W. Hwu Yu, Xuan Dept of Computer & Information Sciences UniversityMore information
Java Virtual Machine: the key for accurated memory prefetching
Java Virtual Machine: the key for accurated memory prefetching Yolanda Becerra Jordi Garcia Toni Cortes Nacho Navarro Computer Architecture Department Universitat Politècnica de Catalunya Barcelona, SpainMore information
Categories and Subject Descriptors C.1.1 [Processor Architecture]: Single Data Stream Architectures. General Terms Performance, Design.
Enhancing Memory Level Parallelism via Recovery-Free Value Prediction Huiyang Zhou Thomas M. Conte Department of Electrical and Computer Engineering North Carolina State University 1-919-513-2014 {hzhou,More information
A-DRM: Architecture-aware Distributed Resource Management of Virtualized Clusters
A-DRM: Architecture-aware Distributed Resource Management of Virtualized Clusters Hui Wang, Canturk Isci, Lavanya Subramanian, Jongmoo Choi, Depei Qian, Onur Mutlu Beihang University, IBM Thomas J. WatsonMore information
An Evaluation of OpenMP on Current and Emerging Multithreaded/Multicore Processors
An Evaluation of OpenMP on Current and Emerging Multithreaded/Multicore Processors Matthew Curtis-Maury, Xiaoning Ding, Christos D. Antonopoulos, and Dimitrios S. Nikolopoulos The College of William &More information
Computer Architecture
Cache Memory Gábor Horváth 2016. április 27. Budapest associate professor BUTE Dept. Of Networked Systems and Services firstname.lastname@example.com It is the memory,... The memory is a serious bottleneck of NeumannMore information
DELL. Virtual Desktop Infrastructure Study END-TO-END COMPUTING. Dell Enterprise Solutions Engineering
DELL Virtual Desktop Infrastructure Study END-TO-END COMPUTING Dell Enterprise Solutions Engineering 1 THIS WHITE PAPER IS FOR INFORMATIONAL PURPOSES ONLY, AND MAY CONTAIN TYPOGRAPHICAL ERRORS AND TECHNICALMore information
Full Speed Ahead: Detailed Architectural Simulation at Near-Native Speed
1 Full Speed Ahead: Detailed Architectural Simulation at Near-Native Speed Andreas Sandberg Erik Hagersten David Black-Schaffer Abstract Popular microarchitecture simulators are typically several ordersMore information
A Hybrid Analytical Modeling of Pending Cache Hits, Data Prefetching, and MSHRs 1
A Hybrid Analytical Modeling of Pending Cache Hits, Data Prefetching, and MSHRs 1 XI E. CHEN and TOR M. AAMODT University of British Columbia This paper proposes techniques to predict the performance impactMore information
Multi-Threading Performance on Commodity Multi-Core Processors
Multi-Threading Performance on Commodity Multi-Core Processors Jie Chen and William Watson III Scientific Computing Group Jefferson Lab 12000 Jefferson Ave. Newport News, VA 23606 Organization IntroductionMore information
OBJECT-ORIENTED programs are becoming more common
IEEE TRANSACTIONS ON COMPUTERS, VOL. 58, NO. 9, SEPTEMBER 2009 1153 Virtual Program Counter (VPC) Prediction: Very Low Cost Indirect Branch Prediction Using Conditional Branch Prediction Hardware HyesoonMore information
Measuring Cache Performance
Measuring Cache Performance Components of CPU time Program execution cycles Includes cache hit time Memory stall cycles Mainly from cache misses With simplifying assumptions: Memory stall cycles = = MemoryMore information
A Comparison of Capacity Management Schemes for Shared CMP Caches
A Comparison of Capacity Management Schemes for Shared CMP Caches Carole-Jean Wu and Margaret Martonosi Department of Electrical Engineering Princeton University {carolewu, email@example.com AbstractMore information
Elemental functions: Writing data-parallel code in C/C++ using Intel Cilk Plus
Elemental functions: Writing data-parallel code in C/C++ using Intel Cilk Plus A simple C/C++ language extension construct for data parallel operations Robert Geva firstname.lastname@example.com Introduction IntelMore information
Dynamic Virtual Machine Scheduling in Clouds for Architectural Shared Resources
Dynamic Virtual Machine Scheduling in Clouds for Architectural Shared Resources JeongseobAhn,Changdae Kim, JaeungHan,Young-ri Choi,and JaehyukHuh KAIST UNIST {jeongseob, cdkim, juhan, and email@example.com information
Scalable Cache Miss Handling For High MLP
Scalable Cache Miss Handling For High MLP James Tuck, Luis Ceze, and Josep Torrellas University of Illinois at Urbana-Champaign http://iacoma.cs.uiuc.edu Introduction Checkpointed processors are promisingMore information
Lecture 11: Multi-Core and GPU. Multithreading. Integration of multiple processor cores on a single chip.
Lecture 11: Multi-Core and GPU Multi-core computers Multithreading GPUs General Purpose GPUs Zebo Peng, IDA, LiTH 1 Multi-Core System Integration of multiple processor cores on a single chip. To provideMore information
Binary search tree with SIMD bandwidth optimization using SSE
Binary search tree with SIMD bandwidth optimization using SSE Bowen Zhang, Xinwei Li 1.ABSTRACT In-memory tree structured index search is a fundamental database operation. Modern processors provide tremendousMore information
More on Pipelining and Pipelines in Real Machines CS 333 Fall 2006 Main Ideas Data Hazards RAW WAR WAW More pipeline stall reduction techniques Branch prediction» static» dynamic bimodal branch predictionMore information
Hardware-Aware Analysis and. Presentation Date: Sep 15 th 2009 Chrissie C. Cui
Hardware-Aware Analysis and Optimization of Stable Fluids Presentation Date: Sep 15 th 2009 Chrissie C. Cui Outline Introduction Highlights Flop and Bandwidth Analysis Mehrstellen Schemes Advection CachingMore information
COMPUTER ORGANIZATION ARCHITECTURES FOR EMBEDDED COMPUTING 2013/2014 1 st Semester Sample Exam January 2014 Duration: 2h00 - No extra material allowed. This includes notes, scratch paper, calculator, etc.More information
Parallel Algorithm Engineering
Parallel Algorithm Engineering Kenneth S. Bøgh PhD Fellow Based on slides by Darius Sidlauskas Outline Background Current multicore architectures UMA vs NUMA The openmp framework Examples Software crisisMore information
FACT: a Framework for Adaptive Contention-aware Thread migrations
FACT: a Framework for Adaptive Contention-aware Thread migrations Kishore Kumar Pusukuri Department of Computer Science and Engineering University of California, Riverside, CA 92507. firstname.lastname@example.com information
SOS: Software-Based Out-of-Order Scheduling for High-Performance NAND Flash-Based SSDs
SOS: Software-Based Out-of-Order Scheduling for High-Performance NAND -Based SSDs Sangwook Shane Hahn, Sungjin Lee, and Jihong Kim Department of Computer Science and Engineering, Seoul National University,More information
CSE 30321 Computer Architecture I Fall 2009 Final Exam December 18, 2009
CSE 30321 Computer Architecture I Fall 2009 Final Exam December 18, 2009 Test Guidelines: 1. Place your name on EACH page of the test in the space provided. 2. every question in the space provided. IfMore information
Intelligent Heuristic Construction with Active Learning
Intelligent Heuristic Construction with Active Learning William F. Ogilvie, Pavlos Petoumenos, Zheng Wang, Hugh Leather E H U N I V E R S I T Y T O H F G R E D I N B U Space is BIG! Hubble Ultra-Deep FieldMore information
Cache Capacity and Memory Bandwidth Scaling Limits of Highly Threaded Processors
Cache Capacity and Memory Bandwidth Scaling Limits of Highly Threaded Processors Jeff Stuecheli 12 Lizy Kurian John 1 1 Department of Electrical and Computer Engineering, University of Texas at AustinMore information
CPU Performance Evaluation: Cycles Per Instruction (CPI) Most computers run synchronously utilizing a CPU clock running at a constant clock rate:
CPU Performance Evaluation: Cycles Per Instruction (CPI) Most computers run synchronously utilizing a CPU clock running at a constant clock rate: Clock cycle where: Clock rate = 1 / clock cycle f = 1 /CMore information
A Content-Based Load Balancing Algorithm for Metadata Servers in Cluster File Systems*
A Content-Based Load Balancing Algorithm for Metadata Servers in Cluster File Systems* Junho Jang, Saeyoung Han, Sungyong Park, and Jihoon Yang Department of Computer Science and Interdisciplinary ProgramMore information
Multicore and Parallel Processing
Multicore and Parallel Processing Hakim Weatherspoon CS 3410, Spring 2012 Computer Science Cornell University P & H Chapter 4.10 11, 7.1 6 Administrivia FlameWar Games Night Next Friday, April 27 th 5pmMore information
Evaluation Report: Accelerating SQL Server Database Performance with the Lenovo Storage S3200 SAN Array
Evaluation Report: Accelerating SQL Server Database Performance with the Lenovo Storage S3200 SAN Array Evaluation report prepared under contract with Lenovo Executive Summary Even with the price of flashMore information
Performance Characteristics of VMFS and RDM VMware ESX Server 3.0.1
Performance Study Performance Characteristics of and RDM VMware ESX Server 3.0.1 VMware ESX Server offers three choices for managing disk access in a virtual machine VMware Virtual Machine File SystemMore information
KerMon: Framework for in-kernel performance and energy monitoring
1 KerMon: Framework for in-kernel performance and energy monitoring Diogo Antão Abstract Accurate on-the-fly characterization of application behavior requires assessing a set of execution related parametersMore information
Q-Clouds: Managing Performance Interference Effects for QoS-Aware Clouds
: Managing Performance Interference Effects for QoS-Aware Clouds Ripal Nathuji and Aman Kansal Microsoft Research Redmond, WA 98052 {ripaln, firstname.lastname@example.com Alireza Ghaffarkhah University of NewMore information
Assessing the Performance of OpenMP Programs on the Intel Xeon Phi
Assessing the Performance of OpenMP Programs on the Intel Xeon Phi Dirk Schmidl, Tim Cramer, Sandra Wienke, Christian Terboven, and Matthias S. Müller firstname.lastname@example.com Rechen- und KommunikationszentrumMore information
Reconfigurable Architecture Requirements for Co-Designed Virtual Machines
Reconfigurable Architecture Requirements for Co-Designed Virtual Machines Kenneth B. Kent University of New Brunswick Faculty of Computer Science Fredericton, New Brunswick, Canada firstname.lastname@example.com Micaela SerraMore information
OpenFOAM: Computational Fluid Dynamics. Gauss Siedel iteration : (L + D) * x new = b - U * x old
OpenFOAM: Computational Fluid Dynamics Gauss Siedel iteration : (L + D) * x new = b - U * x old What s unique about my tuning work The OpenFOAM (Open Field Operation and Manipulation) CFD Toolbox is aMore information
Characterizing Task Usage Shapes in Google s Compute Clusters
Characterizing Task Usage Shapes in Google s Compute Clusters Qi Zhang University of Waterloo email@example.com Joseph L. Hellerstein Google Inc. firstname.lastname@example.com Raouf Boutaba University of Waterloo firstname.lastname@example.com information
Measuring Cache and Memory Latency and CPU to Memory Bandwidth
White Paper Joshua Ruggiero Computer Systems Engineer Intel Corporation Measuring Cache and Memory Latency and CPU to Memory Bandwidth For use with Intel Architecture December 2008 1 321074 Executive SummaryMore information
Interpreters and virtual machines. Interpreters. Interpreters. Why interpreters? Tree-based interpreters. Text-based interpreters
Interpreters and virtual machines Michel Schinz 2007 03 23 Interpreters Interpreters Why interpreters? An interpreter is a program that executes another program, represented as some kind of data-structure.More information
Base-Delta-Immediate Compression: Practical Data Compression for On-Chip Caches
Base-Delta-Immediate Compression: Practical Data Compression for On-Chip Caches Gennady Pekhimenko firstname.lastname@example.com Vivek Seshadri firstname.lastname@example.com Onur Mutlu firstname.lastname@example.com Michael A. Kozuch email@example.com information
Achieving Nanosecond Latency Between Applications with IPC Shared Memory Messaging
Achieving Nanosecond Latency Between Applications with IPC Shared Memory Messaging In some markets and scenarios where competitive advantage is all about speed, speed is measured in micro- and even nano-seconds.More information
How Much Power Oversubscription is Safe and Allowed in Data Centers?
How Much Power Oversubscription is Safe and Allowed in Data Centers? Xing Fu, Xiaorui Wang University of Tennessee, Knoxville, TN 37996 The Ohio State University, Columbus, OH 43210 {xfu1, firstname.lastname@example.com information
Muse Server Sizing. 18 June 2012. Document Version 0.0.1.9 Muse 220.127.116.11
Muse Server Sizing 18 June 2012 Document Version 0.0.1.9 Muse 184.108.40.206 Notice No part of this publication may be reproduced stored in a retrieval system, or transmitted, in any form or by any means, withoutMore information
System Requirements Table of contents
Table of contents 1 Introduction... 2 2 Knoa Agent... 2 2.1 System Requirements...2 2.2 Environment Requirements...4 3 Knoa Server Architecture...4 3.1 Knoa Server Components... 4 3.2 Server Hardware Setup...5More information
Scheduling Task Parallelism" on Multi-Socket Multicore Systems"
Scheduling Task Parallelism" on Multi-Socket Multicore Systems" Stephen Olivier, UNC Chapel Hill Allan Porterfield, RENCI Kyle Wheeler, Sandia National Labs Jan Prins, UNC Chapel Hill Outline" IntroductionMore information
The Effect of Input Data on Program Vulnerability
The Effect of Input Data on Program Vulnerability Vilas Sridharan and David R. Kaeli Department of Electrical and Computer Engineering Northeastern University {vilas, firstname.lastname@example.com I. INTRODUCTIONMore information
Managing GPU Concurrency in Heterogeneous Architectures
Managing Concurrency in Heterogeneous Architectures Onur Kayıran Nachiappan Chidambaram Nachiappan Adwait Jog Rachata Ausavarungnirun Mahmut T. Kandemir Gabriel H. Loh Onur Mutlu Chita R. Das The PennsylvaniaMore information
Solution: start more than one instruction in the same clock cycle CPI < 1 (or IPC > 1, Instructions per Cycle) Two approaches:
Multiple-Issue Processors Pipelining can achieve CPI close to 1 Mechanisms for handling hazards Static or dynamic scheduling Static or dynamic branch handling Increase in transistor counts (Moore s Law):More information
Testing Database Performance with HelperCore on Multi-Core Processors
Project Report on Testing Database Performance with HelperCore on Multi-Core Processors Submitted by Mayuresh P. Kunjir M.E. (CSA) Mahesh R. Bale M.E. (CSA) Under Guidance of Dr. T. Matthew Jacob ProblemMore information
TaP: Table-based Prefetching for Storage Caches
: Table-based Prefetching for Storage Caches Mingju Li University of New Hampshire firstname.lastname@example.com Swapnil Bhatia University of New Hampshire email@example.com Elizabeth Varki University of New HampshireMore information
D1.2 Network Load Balancing
D1. Network Load Balancing Ronald van der Pol, Freek Dijkstra, Igor Idziejczak, and Mark Meijerink SARA Computing and Networking Services, Science Park 11, 9 XG Amsterdam, The Netherlands June firstname.lastname@example.com,firstname.lastname@example.com,More information
Copyright www.agileload.com 1
Copyright www.agileload.com 1 INTRODUCTION Performance testing is a complex activity where dozens of factors contribute to its success and effective usage of all those factors is necessary to get the accurateMore information
Review and Fundamentals
Review and Fundamentals Nima Honarmand Measuring and Reporting Performance Performance Metrics Latency (execution/response time): time to finish one task Throughput (bandwidth): number of tasks/unit timeMore information
In-Memory Databases Algorithms and Data Structures on Modern Hardware. Martin Faust David Schwalb Jens Krüger Jürgen Müller
In-Memory Databases Algorithms and Data Structures on Modern Hardware Martin Faust David Schwalb Jens Krüger Jürgen Müller The Free Lunch Is Over 2 Number of transistors per CPU increases Clock frequencyMore information
DynaMOS: Dynamic Schedule Migration for Heterogeneous Cores
DynaMOS: Dynamic Schedule Migration for Heterogeneous Cores Shruti Padmanabha, Andrew Lukefahr, Reetuparna Das, and Scott Mahlke Advanced Computer Architecture Laboratory University of Michigan, Ann Arbor,More information
Characterizing the Unique and Diverse Behaviors in Existing and Emerging General-Purpose and Domain-Specific Benchmark Suites
Characterizing the Unique and Diverse Behaviors in Existing and Emerging General-Purpose and Domain-Specific Benchmark Suites Kenneth Hoste Lieven Eeckhout ELIS Department, Ghent University Sint-PietersnieuwstraatMore information
MAQAO Performance Analysis and Optimization Tool
MAQAO Performance Analysis and Optimization Tool Andres S. CHARIF-RUBIAL email@example.com Performance Evaluation Team, University of Versailles S-Q-Y http://www.maqao.org VI-HPS 18 th Grenoble 18/22More information
SIDN Server Measurements
SIDN Server Measurements Yuri Schaeffer 1, NLnet Labs NLnet Labs document 2010-003 July 19, 2010 1 Introduction For future capacity planning SIDN would like to have an insight on the required resourcesMore information
On Benchmarking Popular File Systems
On Benchmarking Popular File Systems Matti Vanninen James Z. Wang Department of Computer Science Clemson University, Clemson, SC 2963 Emails: {mvannin, firstname.lastname@example.com Abstract In recent years,More information
Wiggins/Redstone: An On-line Program Specializer
Wiggins/Redstone: An On-line Program Specializer Dean Deaver Rick Gorton Norm Rubin {dean.deaver,rick.gorton,email@example.com Hot Chips 11 Wiggins/Redstone 1 W/R is a Software System That: u MakesMore information
PART IV Performance oriented design, Performance testing, Performance tuning & Performance solutions. Outline. Performance oriented design
PART IV Performance oriented design, Performance testing, Performance tuning & Performance solutions Slide 1 Outline Principles for performance oriented design Performance testing Performance tuning GeneralMore information
secubt : Hacking the Hackers with User-Space Virtualization
secubt : Hacking the Hackers with User-Space Virtualization Mathias Payer Department of Computer Science ETH Zurich Abstract In the age of coordinated malware distribution and zero-day exploits securityMore information
STABILIZER: Statistically Sound Performance Evaluation
STABILIZER: Statistically Sound Performance Evaluation Charlie Curtsinger Emery D. Berger Department of Computer Science University of Massachusetts Amherst Amherst, MA 01003 {charlie,email@example.com information
ScaAnalyzer: A Tool to Identify Memory Scalability Bottlenecks in Parallel Programs
ScaAnalyzer: A Tool to Identify Memory Scalability Bottlenecks in Parallel Programs ABSTRACT Xu Liu Department of Computer Science College of William and Mary Williamsburg, VA 23185 email@example.com It isMore information
CS 147: Computer Systems Performance Analysis
CS 147: Computer Systems Performance Analysis CS 147: Computer Systems Performance Analysis 1 / 39 Overview Overview Overview What is a Workload? Instruction Workloads Synthetic Workloads Exercisers andMore information
Precise and Accurate Processor Simulation
Precise and Accurate Processor Simulation Harold Cain, Kevin Lepak, Brandon Schwartz, and Mikko H. Lipasti University of Wisconsin Madison http://www.ece.wisc.edu/~pharm Performance Modeling AnalyticalMore information
Overlapping Data Transfer With Application Execution on Clusters
Overlapping Data Transfer With Application Execution on Clusters Karen L. Reid and Michael Stumm email@example.com firstname.lastname@example.com Department of Computer Science Department of Electrical and ComputerMore information
Evaluating the Effect of Online Data Compression on the Disk Cache of a Mass Storage System
Evaluating the Effect of Online Data Compression on the Disk Cache of a Mass Storage System Odysseas I. Pentakalos and Yelena Yesha Computer Science Department University of Maryland Baltimore County Baltimore,More information
FPGA area allocation for parallel C applications
1 FPGA area allocation for parallel C applications Vlad-Mihai Sima, Elena Moscu Panainte, Koen Bertels Computer Engineering Faculty of Electrical Engineering, Mathematics and Computer Science Delft UniversityMore information
Concept of Cache in web proxies
Concept of Cache in web proxies Chan Kit Wai and Somasundaram Meiyappan 1. Introduction Caching is an effective performance enhancing technique that has been used in computer systems for decades. However,More information
COMP 422, Lecture 3: Physical Organization & Communication Costs in Parallel Machines (Sections 2.4 & 2.5 of textbook)
COMP 422, Lecture 3: Physical Organization & Communication Costs in Parallel Machines (Sections 2.4 & 2.5 of textbook) Vivek Sarkar Department of Computer Science Rice University email@example.com COMPMore information
AMD Opteron Quad-Core
AMD Opteron Quad-Core a brief overview Daniele Magliozzi Politecnico di Milano Opteron Memory Architecture native quad-core design (four cores on a single die for more efficient data sharing) enhancedMore information
Online Adaptation for Application Performance and Efficiency
Online Adaptation for Application Performance and Efficiency A Dissertation Proposal by Jason Mars 20 November 2009 Submitted to the graduate faculty of the Department of Computer Science at the UniversityMore information
MCCCSim A Highly Configurable Multi Core Cache Contention Simulator
MCCCSim A Highly Configurable Multi Core Cache Contention Simulator Michael Zwick, Marko Durkovic, Florian Obermeier, Walter Bamberger and Klaus Diepold Lehrstuhl für Datenverarbeitung Technische UniversitätMore information
find model parameters, to validate models, and to develop inputs for models. c 1994 Raj Jain 7.1
Monitors Monitor: A tool used to observe the activities on a system. Usage: A system programmer may use a monitor to improve software performance. Find frequently used segments of the software. A systemsMore information
Efficient IP-Address Lookup with a Shared Forwarding Table for Multiple Virtual Routers
Efficient IP-Address Lookup with a Shared Forwarding Table for Multiple Virtual Routers ABSTRACT Jing Fu KTH, Royal Institute of Technology Stockholm, Sweden email@example.com Virtual routers are a promisingMore information
Visualization Enables the Programmer to Reduce Cache Misses
Visualization Enables the Programmer to Reduce Cache Misses Kristof Beyls and Erik H. D Hollander and Yijun Yu Electronics and Information Systems Ghent University Sint-Pietersnieuwstraat 41, Gent, BelgiumMore information
A Study on the Scalability of Hybrid LS-DYNA on Multicore Architectures
11 th International LS-DYNA Users Conference Computing Technology A Study on the Scalability of Hybrid LS-DYNA on Multicore Architectures Yih-Yih Lin Hewlett-Packard Company Abstract In this paper, theMore information
Optimizing Parallel Reduction in CUDA. Mark Harris NVIDIA Developer Technology
Optimizing Parallel Reduction in CUDA Mark Harris NVIDIA Developer Technology Parallel Reduction Common and important data parallel primitive Easy to implement in CUDA Harder to get it right Serves asMore information
Using Synology SSD Technology to Enhance System Performance Synology Inc.
Using Synology SSD Technology to Enhance System Performance Synology Inc. Synology_SSD_Cache_WP_ 20140512 Table of Contents Chapter 1: Enterprise Challenges and SSD Cache as Solution Enterprise Challenges...More information
Who Cares about Memory Hierarchy?
Cache Design Who Cares about Memory Hierarchy? Processor vs Memory Performance CPU-DRAM Gap 1980: no cache in microprocessor; 1995 2-level cache Memory Cache cpu cache memory Memory Locality Memory hierarchiesMore information
Advanced Computer Architecture-CS501. Computer Systems Design and Architecture 2.1, 2.2, 3.2
Lecture Handout Computer Architecture Lecture No. 2 Reading Material Vincent P. Heuring&Harry F. Jordan Chapter 2,Chapter3 Computer Systems Design and Architecture 2.1, 2.2, 3.2 Summary 1) A taxonomy ofMore information


text:
It's that time again! Is the turkey ready to go? Are the pies baked and set to be devoured by all the empty stomachs coming to dinner tonight?
Thanksgiving is one of the best days out of the year because you're finally able to sit back and appreciate everyone and everything you have in your life. In our fast-paced society, we rarely have time to take a second to breathe and be thankful for what we have.
When you gather around the table this thanksgiving, don't forget to verbally thank those around you that have supported you in any way throughout your life. You may think you don't have to say it out loud, but trust us -- you'll be glad you did.
Happy Thanksgiving!


text:
I like this video I don't like this video
76% (32 votes)
Duration: 121min 16sec Views: 17 818 Submitted: 2 years ago Submitted by:
Description: The full title of this video is Oh No, I Had Ejaculated It In Vagina! Starring 2010 new actress Ellis Nakayama. A kinda cute actress with small breasts, small body and sporting a typical girlfriend look to her. In this video, it's nakadashi baby! actors ejaculating right into her pussy for some creampie action.
Categories: Asian Creampie/Nakadashi Japanese Threesomes JAV Censored
Tags: Small Tits Girlfriend Creampie ejaculating Cum Inside Cum Orgasm Oriental Asian Japanese exotic Ethnic Threesome
Models: Ellis Nakayama
- Related Videos
- More Videos with Ellis Nakayama


text: I will be visitng Pittsburgh the weekend of April 23rd. On Saturday, a group is going to the Warhol Museum. We need a recommendation for a place with vegetarian options. We will consider Thai, Mexican, Chinese or any other ethnic type of place. But will not have to be limited to those choices. A chain restaurant is NOT an option. Thanks is advance


text:
- About
- For researchers
- For organizations
- Contact us
- Log in or Sign up
Data from: Genomic and phenotypic architecture of a spruce hybrid zone (Picea sitchensis x P. glauca)
Date Published: August 8, 2012
DOI: http://dx.doi.org/10.5061/dryad.s11b6
Content in the Dryad Digital Repository is offered "as is." By downloading files, you agree to the Dryad Terms of Service. To the extent possible under law, the authors have waived all copyright and related or neighboring rights to this data.
|43 times
|Individual (GenotypeID) and Population data for individuals genotyped and phenotyped from common garden experiment. TenYR_Height is height at 10 years of age (mm) and ColdInjury.8 and ColdInjury.18 is a proportion of injury at -8C and -18C. respectively
|DataDryad_PopulationData.txt (620.0 Kb)
|View File Details
When using this data, please cite the original publication:
Additionally, please cite the Dryad data package:
We encourage organizations to:


text:
Here are 3-steps to help get you started. In addition, find more details about installing the Kodak Picture Saver Scanner's software and drivers onto your computer. See the appropriate tab for either Windows, or Mac operating system.
E-Z Photo Scan has put together a series of short videos to help provide an overview in getting started with your new scanner.
Getting Started: What's in the Box / Unpacking
Getting Started: Setting up Scanning Profiles
Getting Started: Smart Touch (Windows OS)
Getting Started: Smart Touch Using a Job Setting (Windows OS)
Getting Started: MAC Driver Install & Presto! PageManager (Mac OS)
Getting Started: Kodak Picture Scanner drivers PS80 and Legal Flatbed on OS X El Capitan (Mac OS)
Step 2- User Manual
The manufacturer of your scanner has put together an easy-to-read User's manual. In this guide, you will find installation, scanning photos, maintenance, and troubleshooting helps.
The manuals located in the Support Tab can be accessed here.
Get started by installing the appropriate software application(s) for your specific equipment and configuration.
Kodak Photo Scanners include a disc with each unit containing certain software applications. Since not all software required for specific operating systems are on the disc and to guarantee installation with the most up-to-date software it is recommended you use only the software applications downloaded directly from Kodak Alaris.
Software applications may be accessed using the Support Tab on this Kodak Alaris webpage.
Remember to check your the user's manual for the software configuration available for your Kodak Picture Saver Scanning System. Always re-boot your computer after installing the software application(s) for your specific equipment and configuration before attempting to scan.
By downloading from Kodak, you agree to the terms & conditions outlined in the license agreement.
Download the appropriate application(s), based on your purchase;
Kodak Photo Scanner


text:
It only takes a minute to get started. Fill out our uncomplicated sign up form and login to the website.
This step is discretionary but will seriously multiply your chances of people actually reading your profile and contacting you. Introduce yourself, your pasttimes and upload a nice photo of yourself.
Utilise our website's cutting-edge search to pinpoint members who satisfy your requirements. Or just scan through listings and pinpoint folks that you find interesting.
Discovered someone who looks suitable? Send a note to them or just a wink and await their reply. With a little luck you'll be on your way to finding your ideal date.
It'll only take a few minutes