@conference {17984,
	title = {Resource-Aware Compiler Prefetching for Many-Cores},
	booktitle = {Parallel and Distributed Computing (ISPDC), 2010 Ninth International Symposium on},
	year = {2010},
	month = {2010/07//},
	pages = {133 - 140},
	abstract = {Super-scalar, out-of-order processors that can have tens of read and write requests in the execution window place significant demands on Memory Level Parallelism (MLP). Multi-and many-cores with shared parallel caches further increase MLP demand. Current cache hierarchies however have been unable to keep up with this trend, with modern designs allowing only 4-16 concurrent cache misses. This disconnect is exacerbated by recent highly parallel architectures (e.g. GPUs) where power and area per-core budget favor lighter cores with less resources. Support for hardware and software prefetch increase MLP pressure since these techniques overlap multiple memory requests with existing computation. In this paper, we propose and evaluate a novel Resource-Aware Prefetching (RAP) compiler algorithm that is aware of the number of simultaneous prefetches supported, and optimized for the same. We show that in situations where not enough resources are available to issue prefetch instructions for all references in a loop, it is more beneficial to decrease the prefetch distance and prefetch for as many references as possible, rather than use a fixed prefetched distance and skip prefetching for some references, as in current approaches. We implemented our algorithm in a GCC-derived compiler and evaluated its performance using an emerging fine-grained many-core architecture. Our results show that the RAP algorithm outperforms a well-known loop prefetching algorithm by up to 40.15\% and the state-of-the art GCC implementation by up to 34.79\%. Moreover, we compare the RAP algorithm with a simple hardware prefetching mechanism, and show improvements of up to 24.61\%.},
	keywords = {algorithm;memory, architecture;hardware-software, architectures;parallel, architectures;resource, aware, caches;super-scalar, compiler, compiler;Multicore, compilers;parallel, GCC-derived, level, management;, many-core, memories;storage, out-of-order, Parallel, parallelism;parallel, prefetch;loop, prefetching, prefetching;shared, processor;fine-grained, processors;multiprocessing, systems;optimising},
	doi = {10.1109/ISPDC.2010.16},
	author = {Caragea,G.C. and Tzannes,A. and Keceli,F. and Barua,R. and Vishkin, Uzi}
}
@article {14708,
	title = {Modular Information Hiding and Type-Safe Linking for C},
	journal = {IEEE Transactions on Software Engineering},
	volume = {34},
	year = {2008},
	month = {2008/06//May},
	pages = {357 - 376},
	abstract = {This paper presents CMod, a novel tool that provides a sound module system for C. CMod works by enforcing four rules that are based on principles of modular reasoning and on current programming practice. CMod{\textquoteright}s rules flesh out the convention that .h header files are module interfaces and .c source files are module implementations. Although this convention is well-known, existing explanations of it are incomplete, omitting important subtleties needed for soundness. In contrast, we have proven formally that CMod{\textquoteright}s rules enforce both information hiding and type-safe linking. To use CMod, the programmer develops and builds their software as usual, redirecting the compiler and linker to CMod{\textquoteright}s wrappers. We evaluated CMod by applying it to 30 open source programs, totaling more than one million LoC. Violations to CMod{\textquoteright}s rules revealed more than a thousand information hiding errors, dozens of typing errors, and hundreds of cases that, although not currently bugs, make programming mistakes more likely as the code evolves. At the same time, programs generally adhere to the assumptions underlying CMod{\textquoteright}s rules, and so we could fix rule violations with a modest effort. We conclude that CMod can effectively support modular programming in C: it soundly enforces type-safe linking and information-hiding while being largely compatible with existing practice.},
	keywords = {C language, CMOD, Code design, Coding Tools and Techniques, compiler, data encapsulation, Information hiding, modular information hiding, modular reasoning, modules, object-oriented programming, open source programs, packages, program compilers, public domain software, reliability, software reusability, type-safe linking},
	isbn = {0098-5589},
	doi = {10.1109/TSE.2008.25},
	author = {Srivastava,S. and Hicks, Michael W. and Foster, Jeffrey S. and Jenkins,P.}
}
@article {18408,
	title = {Optimization of structured programs},
	journal = {Software: Practice and Experience},
	volume = {4},
	year = {2006},
	month = {2006/10/27/},
	pages = {51 - 57},
	abstract = {The class of programs which do not contain goto statements has a structure which lends itself to optimization by an optimizer that is fast, efficient and relatively easy to program. The design of such an optimizer is described, along with some of the results obtained using this optimizer{\textemdash}one such result being that very little code optimization is achieved. The conjecture is made that this is true because gotoless programming languages lend themselves to more compact and concise object code at the source language level.},
	keywords = {compiler, Nested control structures, Optimizer, structured programming},
	isbn = {1097-024X},
	doi = {10.1002/spe.4380040106},
	url = {http://onlinelibrary.wiley.com/doi/10.1002/spe.4380040106/abstract},
	author = {Zelkowitz, Marvin V and Bail,William G}
}
