The second Data Prefetching Championship (DPC) is a competition for data prefetching algorithms. Contestants will be given a fixed storage budget to implement their best prefetching algorithms on a common evaluation framework provided by the DPC organizing committee.
Simulation Framework Release: February 6, 2015
Abstract Deadline: April 3, 2015, 11:59:59PM EDT
Paper & Code Deadline: April 7, 2015, 11:59:59PM EDT(No more extension)
Notification: April 20, 2015
Date and Location: June 13, 2015 @ Room C124
Winner: 1st place: Pierre Michaud
2nd place: Vinson Young and Ajit Krisshna
3rd place: Ibrahim Burak Karsli, Mustafa Cavus, and Resit Sendag
The goal for this competition is to compare different data prefetching algorithms in a common framework. Prefetchers for L2 data caches must be implemented within a fixed storage budget as specified in the competition rules. Submissions will be evaluated based on their performance on a set of benchmarks on the framework provided by the organizing committee.
The champion will receive a trophy commemorating his/her triumph. In addition to the top performance champion, the program committee will select the best technical paper from all submissions, which does not necessarily have to be that of the champion. All source code, write-ups and performance results will be made publicly available through the DPC website.
Each contestant is allowed a maximum of three submissions to the competition. Each submission should include the following:
- Abstract: A 300-word abstract summarizing the submission. In addition, the abstract should include the author names, their affiliations, and the email address of the contact author.
- Paper: This will be a conference-quality write-up of the prefetching algorithm, including references to relevant related work. The paper must clearly describe how the algorithm works, how it is practical to implement, and how it conforms to the contest rules. The paper must be written in English and formatted as follows: no more than four pages, single-spaced, two-column format, minimum 10pt Times New Roman font. The paper should be submitted in .pdf format, and should be printable on letter-size paper with one-inch margins. A submission will be disqualified if the paper does not clearly describe the algorithm that corresponds to the submitted code. Papers that do not conform to the length and format rules will only be reviewed at the program committee's discretion.
- Prefetcher code: A single C file that can be included in the provided infrastructure must be submitted along with the paper as a separate file. This code must be well-commented so that it can be understood and evaluated. Unreadable or insufficiently documented code will be rejected by the program committee. The file prefetcher.c from the infrastructure is distributed with a simple prefetcher, and should be replaced with the contestantís code. The prefetcher code should be compiled and run on the existing infrastructure without changing any code or Makefile, and should NOT require any library code that is not part of C++.
More details on where to submit these files will be available soon.
The competition will proceed as follows. The contestant will be responsible for implementing and evaluating their algorithm in the distributed framework. The framework itself should not be modified (except for the prefetcher.c file that implements the prefetching algorithm). You may use 32 KBytes (256 Kbits) of storage to implement state machines to manage your prefetching algorithm. You will not be penalized for the complexity of the algorithm logic. The 32 Kbyte storage can be allocated as you see fit. Submissions will be taken, and the contestant's prefetcher.c (this file only) will be compiled and run with the original version of the framework. The contestants will be ranked on the basis of the measured performance of their prefetching algorithms. Each contestant will get four scores, one for each of four configurations, that measure the geometric mean of their prefetching algorithm speedups across a set of (undistributed) benchmarks. The overall score is the sum of these four scores. For example, if a contestant has scores of 1.05, 1.03, 1.00 and 0.99 for the four configurations, his/her overall score is 4.07.
We have added several functions to help you build your prefetcher: l2_cache_fill(), l2_get_set() and l2_get_way(). The motivation for adding these functions was to facilitate the addition of metadata to each cache line in the L2 cache, by letting you determine which tag array entry corresponds to each incoming cache line, and each accessed cache line. The intent was never to give you a “free” way to check the contents of the L2 in an oracular manner. In line with this, please make sure to only call l2_get_set() and l2_get_way() a maximum of 1 time each in l2_prefetcher_operate(), and never anywhere else. Of course, the use of these functions is optional, but you may find them useful. The judges who review the code will be specifically looking for abuse of these functions.
- In the interest of assembling a quality program for workshop attendees and future readers, there will be an overall selection process, of which performance ranking is a key component, but not the sole component.
- To be considered, submissions must conform to the submission requirements described above.
- Submissions will be selected to appear in the workshop on the basis of the performance ranking, novelty, and overall quality of the paper and commented code. Novelty is not a strict requirement, for example, a contestant may submit his/her previously published prefetchers or make incremental enhancements to previously proposed prefetchers. In such cases, performance is a heavily weighted criterion, as is overall quality of the paper (for example, analysis of new results on the common framework, etc.). Conversely, a very novel submission that is not necessarily a top performer in the competition will be considered not just from a performance standpoint but also on the basis of insights etc.