Logo: to the web site of Uppsala University

uu.sePublications from Uppsala University
Planned maintenance
A system upgrade is planned for 17/11-2026, at 12:00-13:00. During this time DiVA will be unavailable.
Change search
Link to record
Permanent link

Direct link
Black-Schaffer, David, ProfessorORCID iD iconorcid.org/0000-0001-5375-4058
Publications (10 of 75) Show all publications
Yenimol, A. S., Nag, A., Park, C. H. & Black-Schaffer, D. (2026). CoGraf: Fully Accelerating Graph Applications with Fine-Grained PIM. In: ASPLOS '26: Proceedings of the 31st ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2. Paper presented at ASPLOS '26: 31st ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Pittsburgh PA, USA, March 22-26, 2026 (pp. 409-425). Association for Computing Machinery (ACM), 2
Open this publication in new window or tab >>CoGraf: Fully Accelerating Graph Applications with Fine-Grained PIM
2026 (English)In: ASPLOS '26: Proceedings of the 31st ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2, Association for Computing Machinery (ACM), 2026, Vol. 2, p. 409-425Conference paper, Published paper (Refereed)
Abstract [en]

Processing-in-Memory (PIM) delivers enormous performance by taking advantage of internal DRAM bandwidth and parallelism. However, graph applications are difficult to adapt to PIM due to their irregular access patterns.We present the first Fine-Grained PIM (FGPIM) design that fully accelerates vertex-centric push-based graph applications by accelerating both their update (computing vertex updates) and apply (summing up the updates) phases.

For the update phase, we design a tuple-based LLC that can coalesce at different granularities to group graph updates together and propose multi-DRAM column processing FGPIM instructions to match the cache coalescing to the row-level parallelism of the FGPIM. With this acceleration, the apply phase becomes the bottleneck, and we propose bank-parallel FGPIM instructions with predicates to allow FGPIM to accelerate the conditional updates as well. 

We achieve an average speedup in the region of interest of 1.8x/3x compared to naive FGPIM and 4.4x/9.8x compared to state-of-the-art non-PIM baseline (HBM2/DDR4), and DRAM energy reduction of 67%/86% and 88%/94%.These results show the importance of providing a complete solution that accelerates both the update and apply phases.

Place, publisher, year, edition, pages
Association for Computing Machinery (ACM), 2026
National Category
Computer Engineering
Research subject
Computer Science
Identifiers
urn:nbn:se:uu:diva-580183 (URN)10.1145/3779212.3790142 (DOI)001796931700027 ()2-s2.0-105036982882 (Scopus ID)9798400723599 (ISBN)
Conference
ASPLOS '26: 31st ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Pittsburgh PA, USA, March 22-26, 2026
Available from: 2026-02-21 Created: 2026-02-21 Last updated: 2026-08-19Bibliographically approved
Haddadi, A., Black-Schaffer, D. & Park, C. H. (2026). Hiding Page Fault Latencies in Graph Processing Applications that Cannot Fit in Memory. In: 40th IEEE International Parallel & Distributed Processing Symposium (IPDPS) 2026: . Paper presented at The 40th IEEE International Parallel & Distributed Processing Symposium (IPDPS), May 25-29, 2026, New Orleans, USA. Institute of Electrical and Electronics Engineers (IEEE)
Open this publication in new window or tab >>Hiding Page Fault Latencies in Graph Processing Applications that Cannot Fit in Memory
2026 (English)In: 40th IEEE International Parallel & Distributed Processing Symposium (IPDPS) 2026, Institute of Electrical and Electronics Engineers (IEEE), 2026Conference paper, Published paper (Refereed)
Abstract [en]

With graph sizes growing enormously, there is apressing need to efficiently process graphs that cannot fit intoDRAM. The standard solution is synchronous demand paging, which suffers from enormous performance loss as threads idle waiting for data to be brought in from storage. We observe thatt here is sufficient parallelism in graph applications to hide muchof the paging latency, but that the standard approaches suffer from insufficient hardware parallelism to cover storage latencies (symmetric multi-threading) or high software overheads (thread oversubscription).

We propose an application/OS co-design where critical page-fault latencies can be hidden by handling in the user-space.The user-space handler issues page-in requests, and instead of blocking, continues working on other parts of the graph while the data is asynchronously paged in. Another approach is to leverage the information in the user space and issue more accurate readahead requests, effectively prefetching more pages to hide future page fault latencies. These approaches significantly reduce paging overhead for many graphs that do not fit in DRAM.

To evaluate, we added support to the Linux kernel (+160lines) and ran the GAP benchmark suite in a DRAM-constrained configuration. Our results show that our proposal can hide most of the page fault latency, resulting in a 23% performance improvement over a commodity baseline and 13 percentage point improvement over thread oversubscription. Furthermore, to demonstrate the general applicability of our framework, we also applied it to the GUPS and XSBench benchmarks, achieving 52% and 58% speedups, respectively.

Place, publisher, year, edition, pages
Institute of Electrical and Electronics Engineers (IEEE), 2026
National Category
Computer Sciences
Research subject
Computer Science; Computer Science
Identifiers
urn:nbn:se:uu:diva-579092 (URN)10.1109/IPDPS65963.2026.00089 (DOI)
Conference
The 40th IEEE International Parallel & Distributed Processing Symposium (IPDPS), May 25-29, 2026, New Orleans, USA
Projects
the Institute of Infor- mation & communications Technology Planning & Evaluation (IITP) grant funded by the Korea government (MSIT) (No. 2018-0-00503, Researches on next generation memory-centric computing system architecturethe Knut and Alice Wal- lenberg Foundation through the Wallenberg Academy Fellows Program (grant No. KAW 2020.0202)
Available from: 2026-02-12 Created: 2026-02-12 Last updated: 2026-09-11
Haddadi, A., Black-Schaffer, D. & Park, C. H. (2026). It's Not the Storage: Exposing Linux Kernel Bottlenecks in Page Fault Handling on NVMe SSD-backed Systems. In: 2026 IEEE International Symposium on Performance Analysis of Systems and Software (ISPASS): . Paper presented at ISPASS 2026, 2026 IEEE International Symposium on Performance Analysis of Systems and Software, April 26-28, 2026, Seoul, South Korea (pp. 125-136).
Open this publication in new window or tab >>It's Not the Storage: Exposing Linux Kernel Bottlenecks in Page Fault Handling on NVMe SSD-backed Systems
2026 (English)In: 2026 IEEE International Symposium on Performance Analysis of Systems and Software (ISPASS), 2026, p. 125-136Conference paper, Published paper (Refereed)
Abstract [en]

The long latencies of major page faults are often blamed on slow storage, but our study shows that with modern locally attached NVMe SSDs used as swap space, the real culprit is the Linux kernel itself. Indeed, kernel overhead from page table walks, swap cache lookups, block-layer bookkeeping, and interrupt handling frequently exceed the time spent on disk I/O. To explore this, we introduce a lightweight measurement methodology that accurately attributes page fault costs across kernel, I/O, and user-level components. Using representative workloads and microbenchmarks on a single-socket desktop machine, we show that NVMe SSD bandwidth is rarely the bottleneck, and that Linux’s default readahead policy can unpredictably amplify latency. Our findings challenge common assumptions, reveal hidden kernel costs, and point toward opportunities for redesigning page fault handling for modern systems.

Series
IEEE International Symposium on Performance Analysis of Systems and Software
National Category
Computer Sciences
Identifiers
urn:nbn:se:uu:diva-582597 (URN)10.1109/ispass69572.2026.00022 (DOI)
Conference
ISPASS 2026, 2026 IEEE International Symposium on Performance Analysis of Systems and Software, April 26-28, 2026, Seoul, South Korea
Projects
the Institute of Information & communications Technology Planning & Evaluation (IITP) grant funded by the Korea government (MSIT) (No. 2018-0-00503, Researches on next generation memory-centric computing system architecture)the Knut and Alice Wallenberg Foundation through the Wallenberg Academy Fellows Program (grant No. KAW 2020.0202)
Funder
Swedish Research Council, 2023-0327Knut and Alice Wallenberg Foundation, KAW 2020.0202
Available from: 2026-03-19 Created: 2026-03-19 Last updated: 2026-06-05Bibliographically approved
Hassan, M., Park, C. H. & Black-Schaffer, D. (2025). Second-level Caches: Not for Instructions. ACM Transactions on Architecture and Code Optimization (TACO), 22(4), Article ID 138.
Open this publication in new window or tab >>Second-level Caches: Not for Instructions
2025 (English)In: ACM Transactions on Architecture and Code Optimization (TACO), ISSN 1544-3566, E-ISSN 1544-3973, Vol. 22, no 4, article id 138Article in journal (Refereed) Published
Abstract [en]

Growing instruction footprints are straining processor front-ends, increasing fetch latency, and causing pipeline stalls. The universal approach to addressing this has been keeping instructions in each level of the cache hierarchy, but a plethora of more advanced techniques, ranging from instruction prefetching to prioritizing instruction cache-lines, have also been proposed to reduce instruction fetch latency.

In this work we identify a significant subset of benchmarks that exhibit an insensitivity to instruction fetch latency to the extent that we can take the opposite approach and explicitly bypass the L2 for instructions. While conventional wisdom suggests that this will hurt performance, our detailed analysis of 2,120 traces finds that two factors mitigate this effect. First, the presence of ubiquitous effective instruction prefetching in the form of fetch-directed instruction prefetching (FDIP) means that as long as instructions are present in the LLC, the additional latency of missing in the L2 is often insignificant. And, second, by keeping instructions out of the L2, we find that the increase in data locality in the L2 leads to significant performance gains.

Based on our analysis, we propose bypassing the L2 for instructions for a subset of applications and demonstrate how a simple decision tree can be trained offline and used online to cheaply and effectively choose when to bypass. Our technique increases performance by 3.4% geomean for sensitive benchmarks (those that see an improvement of at least 1% with an infinite I-cache) compared to an aggressive FDIP baseline, reaching up to 55% of the perfect I-cache performance with minimal to no overhead.

Place, publisher, year, edition, pages
Association for Computing Machinery (ACM), 2025
National Category
Computer Systems
Identifiers
urn:nbn:se:uu:diva-526289 (URN)10.1145/3769080 (DOI)001667658800015 ()
Funder
Uppsala University
Available from: 2024-04-08 Created: 2024-04-08 Last updated: 2026-03-24Bibliographically approved
Norlinder, J., Osterlund, E., Black-Schaffer, D. & Wrigstad, T. (2024). Mark-Scavenge: Waiting for Trash to Take Itself Out. Proceedings of the ACM on Programming Languages, 8(OOPSLA2), Article ID 351.
Open this publication in new window or tab >>Mark-Scavenge: Waiting for Trash to Take Itself Out
2024 (English)In: Proceedings of the ACM on Programming Languages, E-ISSN 2475-1421, Vol. 8, no OOPSLA2, article id 351Article in journal (Refereed) Published
Abstract [en]

Moving garbage collectors (GCs) typically free memory by evacuating live objects in order to reclaim contiguousmemory regions. Evacuation is typically done either during tracing (scavenging), or after tracing whenidentification of live objects is complete (mark-evacuate). Scavenging typically requires more memory (memoryfor all objects to be moved), but performs less work in sparse memory areas (single pass). This makes itattractive for collecting young objects. Mark-evacuate typically requires less memory and performs lesswork in memory areas with dense object clusters, by focusing relocation around sparse regions, making itattractive for collecting old objects. Mark-evacuate also completes identification of live objects faster, makingit attractive for concurrent GCs that can reclaim memory immediately after identification of live objectsfinishes (as opposed to when evacuation finishes), at the expense of more work compared to scavenging, foryoung objects.We propose an alternative approach for concurrent GCs to combine the benefits of scavenging with thebenefits of mark-evacuate, for young objects. The approach is based on the observation that by the timeyoung objects are relocated by a concurrent GC, they are likely to already be unreachable. By performingrelocation lazily, most of the relocations in the defragmentation phase of mark-evacuate can typically beeliminated. Similar to scavenging, objects are relocated during tracing with the proposed approach. However,instead of relocating all objects that are live in the current GC cycle, it lazily relocates profitable sparse objectclusters that survived from the previous GC cycle. This turns the memory headroom that concurrent GCstypically "waste" in order to safely avoid running out of memory before GC finishes, into an asset used toeliminate much of the relocation work, which constitutes a significant portion of the GC work.We call this technique mark-scavenge and implement it on-top of ZGC in OpenJDK in a collector we callMS-ZGC. We perform a performance evaluation that compares MS-ZGC against ZGC. The most striking resultis (up to) 91% reduction in relocation of dead objects (depending on machine-dependent factors).

Place, publisher, year, edition, pages
Association for Computing Machinery (ACM), 2024
Keywords
concurrent, garbage collection, mark-evacuate, scavenging
National Category
Computer Sciences
Identifiers
urn:nbn:se:uu:diva-546755 (URN)10.1145/3689791 (DOI)001360845100009 ()
Funder
Swedish Research Council, 2020-05346Swedish Foundation for Strategic Research, SM19-0059Swedish Research Council, 2022-06725Swedish Foundation for Strategic ResearchSwedish Research Council
Available from: 2025-01-15 Created: 2025-01-15 Last updated: 2025-01-15Bibliographically approved
Norlinder, J., Yang, A. M., Black-Schaffer, D. & Wrigstad, T. (2024). Mutator-Driven Object Placement using Load Barriers. In: Ertl, MA Kirsch, CM (Ed.), PROCEEDINGS OF THE 21ST ACM SIGPLAN INTERNATIONAL CONFERENCE ON MANAGED PROGRAMMING LANGUAGES AND RUNTIMES, MPLR 2024: . Paper presented at 21st ACM SIGPLAN International Conference on Managed Programming Languages and Runtimes (MPLR), SEP 19-19, 2024, Vienna, AUSTRIA (pp. 14-27). Association for Computing Machinery (ACM)
Open this publication in new window or tab >>Mutator-Driven Object Placement using Load Barriers
2024 (English)In: PROCEEDINGS OF THE 21ST ACM SIGPLAN INTERNATIONAL CONFERENCE ON MANAGED PROGRAMMING LANGUAGES AND RUNTIMES, MPLR 2024 / [ed] Ertl, MA Kirsch, CM, Association for Computing Machinery (ACM), 2024, p. 14-27Conference paper, Published paper (Refereed)
Abstract [en]

Object placement impacts cache utilisation, which is itself critical for performance. Managed languages offer fewer tools than unmanaged languages in the way of controlling object placement due to the abstract view of memory. On the other hand, managed languages often have garbage collectors (CC) that move objects as part of defragmentation. In the context of OpenJDK, Hot -Cold Objects Segregation GC (HCSGC) added locality itnprovement on -top of ZCC by piggybacking on its loaded value -harrier based design. In addition to the open problem of tuning HCSGC, we identify a contradiction in two of its design goals and propose LR, that addresses both these problems. We implement LR on-top of ZCC and compare it with GCs in OpenJDK and with the best performing HCSGC configuration using DaCapo, JCraphT and SPECjbb2015. While using less resources, LR outperforms HCSGC in 18 configurations, matches performance in 17, and regresses in 3.

Place, publisher, year, edition, pages
Association for Computing Machinery (ACM), 2024
Keywords
garbage collection, locality, cache performance
National Category
Computer and Information Sciences
Identifiers
urn:nbn:se:uu:diva-541900 (URN)10.1145/3679007.3685060 (DOI)001321523000003 ()979-8-4007-1118-3 (ISBN)
Conference
21st ACM SIGPLAN International Conference on Managed Programming Languages and Runtimes (MPLR), SEP 19-19, 2024, Vienna, AUSTRIA
Funder
Swedish Research Council, 2020-05346Swedish Foundation for Strategic Research, SM19-0059
Available from: 2024-11-07 Created: 2024-11-07 Last updated: 2024-11-07Bibliographically approved
Nematallah, A., Park, C. H. & Black-Schaffer, D. (2023). Exploring the Latency Sensitivity of Cache Replacement Policies [Letter to the editor]. IEEE Computer Architecture Letters, 22(2), 93-96
Open this publication in new window or tab >>Exploring the Latency Sensitivity of Cache Replacement Policies
2023 (English)In: IEEE Computer Architecture Letters, ISSN 1556-6056, E-ISSN 1556-6064, Vol. 22, no 2, p. 93-96Article in journal, Letter (Refereed) Published
Abstract [en]

With DRAM latencies increasing relative to CPU speeds, the performance of caches has become more important. This has led to increasingly sophisticated replacement policies that require complex calculations to update their replacement metadata, which often require multiple cycles. To minimize the negative impact of these metadata updates, architects have focused on policies that incur as little update latency as possible through a combination of reducing the policies’ precision and using parallel hardware. In this work we investigate whether these tradeoffs to reduce cache metadata update latency are needed. Specifically, we look at the performance and energy impact of increasing the latency of cache replacement policy updates. We find that even dramatic increases in replacement policy update latency have very limited effect. This indicates that designers have far more freedom to increase policy complexity and latency than previously assumed.

Place, publisher, year, edition, pages
Institute of Electrical and Electronics Engineers (IEEE), 2023
Keywords
Cache Replacement Policies, Computer Architecture, High-Performance Computing
National Category
Computer Sciences
Research subject
Computer Science
Identifiers
urn:nbn:se:uu:diva-508114 (URN)10.1109/lca.2023.3296251 (DOI)001049956900003 ()
Funder
Knut and Alice Wallenberg Foundation, 2015.0153EU, Horizon 2020, 715283Swedish Research Council, 2019-02429
Available from: 2023-07-20 Created: 2023-07-20 Last updated: 2026-07-02Bibliographically approved
Borgström, G., Rohner, C. & Black-Schaffer, D. (2023). Faster FunctionalWarming with Cache Merging. In: PROCEEDINGS OF SYSTEM ENGINEERING FOR CONSTRAINED EMBEDDED SYSTEMS, DRONESE AND RAPIDO 2023: . Paper presented at Conference on Drone Systems Engineering (DroneSE) / Conference on Rapid Simulation and Performance Evaluation - Methods and Tools (RAPIDO) / Workshop on System Engineering for Constrained Embedded Systems / HiPEAC Conference, JAN 16-18, 2023, Toulouse, FRANCE (pp. 39-47). Association for Computing Machinery (ACM)
Open this publication in new window or tab >>Faster FunctionalWarming with Cache Merging
2023 (English)In: PROCEEDINGS OF SYSTEM ENGINEERING FOR CONSTRAINED EMBEDDED SYSTEMS, DRONESE AND RAPIDO 2023, Association for Computing Machinery (ACM), 2023, p. 39-47Conference paper, Published paper (Refereed)
Abstract [en]

Smarts-like sampled hardware simulation techniques achieve good accuracy by simulating many small portions of an application in detail. However, while this reduces the simulation time, it results in extensive cache warming times, as each of the many simulation points requires warming the whole memory hierarchy. Adaptive Cache Warming reduces this time by iteratively increasing warming to achieve sufficient accuracy. Unfortunately, each increases requires that the previous warming be redone, nearly doubling the total warming. We address re-warming by developing a technique to merge the cache states from the previous and additional warming iterations. We demonstrate our merging approach on multi-level LRU cache hierarchy and evaluate and address the introduced errors. Our experiments show that Cache Merging delivers an average speedup of 1.44x, 1.84x, and 1.87x for 128kB, 2MB, and 8MB L2 caches, respectively, (vs. a 2x theoretical maximum speedup) with 95-percentile absolute IPC errors of only 0.029, 0.015, and 0.006, respectively. These results demonstrate that Cache Merging yields significantly higher simulation speed with minimal losses.

Place, publisher, year, edition, pages
Association for Computing Machinery (ACM), 2023
Keywords
functional warming, cache warming, cache merging
National Category
Computer Sciences Computer Engineering
Identifiers
urn:nbn:se:uu:diva-519733 (URN)10.1145/3579170.3579256 (DOI)001106628800005 ()979-8-4007-0045-3 (ISBN)
Conference
Conference on Drone Systems Engineering (DroneSE) / Conference on Rapid Simulation and Performance Evaluation - Methods and Tools (RAPIDO) / Workshop on System Engineering for Constrained Embedded Systems / HiPEAC Conference, JAN 16-18, 2023, Toulouse, FRANCE
Available from: 2024-01-09 Created: 2024-01-09 Last updated: 2024-01-09Bibliographically approved
Haddadi, A., Black-Schaffer, D. & Park, C. H. (2023). Large-scale Graph Processing on Commodity Systems: Understanding and Mitigating the Impact of Swapping. In: The International Symposium on Memory Systems (MEMSYS '23): . Paper presented at The International Symposium on Memory Systems (MEMSYS '23), October 2–5, 2023, Alexandria, VA, USA (pp. 1-11). Association for Computing Machinery (ACM), Article ID 2.
Open this publication in new window or tab >>Large-scale Graph Processing on Commodity Systems: Understanding and Mitigating the Impact of Swapping
2023 (English)In: The International Symposium on Memory Systems (MEMSYS '23), Association for Computing Machinery (ACM), 2023, p. 1-11, article id 2Conference paper, Published paper (Refereed)
Abstract [en]

Graph workloads are critical in many areas. Unfortunately, graph sizes have been increasing faster than DRAM capacity. As a result, large-scale graph processing necessarily falls back to virtual memory paging, resulting in tremendous performance losses.

In this work we investigate how we can get the best possible performance on commodity systems from graphs that cannot fit into DRAM by understanding, and adjusting, how the virtual memory system and the graph characteristics interact. To do so, we first characterize the graph applications, system, and SSD behavior as a function of how much of the graph fits in DRAM. From this analysis we see that for multiple graph types, the system fails to fully utilize the bandwidth of the SSDs due to a lack of parallel page-in requests.

We use this insight to motivate overcommitting CPU threads for graph processing. This allows us to significantly increase the number of parallel page-in requests for several graph types, and recover much of the performance lost to paging. We show that overcommitting threads generally improves performance for various algorithms and graph types. However, we identify one graph that suffers from overcommitting threads, leading to the recommendation that overcommitting threads is generally good for performance, but there may be certain graph inputs that suffer from overcommitting threads.

Place, publisher, year, edition, pages
Association for Computing Machinery (ACM), 2023
Keywords
graph processing, virtual memory, swapping, SSD, commodity system, thread overcommitting, characterization, operating system
National Category
Computer Systems
Research subject
Computer Science; Computer Systems Sciences
Identifiers
urn:nbn:se:uu:diva-515500 (URN)10.1145/3631882.3631884 (DOI)001209675300002 ()9798400716447 (ISBN)
Conference
The International Symposium on Memory Systems (MEMSYS '23), October 2–5, 2023, Alexandria, VA, USA
Funder
Knut and Alice Wallenberg Foundation, 2015.0153EU, Horizon 2020, 715283Swedish Research Council, 2019-02429
Note

Funder

Electronics and Telecommunications Research Institute (ETRI)

Grant number: 23ZS1300

Available from: 2023-11-03 Created: 2023-11-03 Last updated: 2024-07-09Bibliographically approved
Hassan, M., Park, C. H. & Black-Schaffer, D. (2023). Protean: Resource-efficient Instruction Prefetching. In: The International Symposium on Memory Systems (MEMSYS '23): . Paper presented at The International Symposium on Memory Systems (MEMSYS '23), October 2–5, 2023, Alexandria, VA, USA (pp. 1-13). Association for Computing Machinery (ACM), Article ID 22.
Open this publication in new window or tab >>Protean: Resource-efficient Instruction Prefetching
2023 (English)In: The International Symposium on Memory Systems (MEMSYS '23), Association for Computing Machinery (ACM), 2023, p. 1-13, article id 22Conference paper, Published paper (Refereed)
Abstract [en]

Increases in code footprint and control flow complexity have made low-latency instruction fetch challenging. Dedicated Instruction Prefetchers (DIPs) can provide performance gains (up to 5%) for a subset of applications that are poorly served by today’s ubiquitous Fetch-Directed Instruction Prefetching (FDIP). However, DIPs incur the significant overhead of in-core metadata storage (for all work- loads) and energy and performance loss from excess prefetches (for many workloads), leading to 11% of workloads actually losing performance. This work addresses how to provide the benefits of a DIP without its costs when the DIP cannot provide a benefit.

Our key insight is that workloads that benefit from DIPs can tolerate increased Branch Target Buffer (BTB) misses. This allows us to dynamically re-purpose the existing BTB storage between the BTB and the DIP. We train a simple performance counter based decision tree to select the optimal configuration at runtime, which allows us to achieve different energy/performance optimization goals. As a result, we pay essentially no area overhead when a DIP is needed, and can use the larger BTB when it is beneficial, or even power it off when not needed.

We look at our impact on two groups of benchmarks: those where the right configuration choice can improve performance or energy and those where the wrong choice could hurt them. For the benchmarks with improvement potential, when optimizing for performance, we are able to obtain 86% of the oracle potential, and when optimizing for energy, 98% of the potential, both while avoid- ing essentially all performance and energy losses on the remaining benchmarks. This demonstrates that our technique is able to dy- namically adapt to different performance/energy goals and obtain essentially all of the potential gains of DIP without the overheads they experience today.

Place, publisher, year, edition, pages
Association for Computing Machinery (ACM), 2023
National Category
Computer Systems
Research subject
Computer Science; Computer Systems Sciences
Identifiers
urn:nbn:se:uu:diva-515499 (URN)10.1145/3631882.3631904 (DOI)001209675300022 ()9798400716447 (ISBN)
Conference
The International Symposium on Memory Systems (MEMSYS '23), October 2–5, 2023, Alexandria, VA, USA
Funder
Knut and Alice Wallenberg Foundation, 2015.0153EU, Horizon 2020, 715283Swedish Research Council, 2019-02429
Note

Funder

Electronics and Telecommunications Research Institute (ETRI)

Grant number: 23ZS1300

Available from: 2023-11-03 Created: 2023-11-03 Last updated: 2024-07-09Bibliographically approved
Projects
Proactive Memory Hierarchy Management [2014-05480_VR]; Uppsala UniversityApplication-specific Coherence for Concurrent Acceleration of Managed Language [2019-04275_VR]; Uppsala UniversityRevisiting branch prediction: Can we use broader contextual information to find better patterns? [2024-04443_VR]; Uppsala University; Publications
Haddadi, A., Black-Schaffer, D. & Park, C. H. (2026). Hiding Page Fault Latencies in Graph Processing Applications that Cannot Fit in Memory. In: 40th IEEE International Parallel & Distributed Processing Symposium (IPDPS) 2026: . Paper presented at The 40th IEEE International Parallel & Distributed Processing Symposium (IPDPS), May 25-29, 2026, New Orleans, USA. Institute of Electrical and Electronics Engineers (IEEE)
Organisations
Identifiers
ORCID iD: ORCID iD iconorcid.org/0000-0001-5375-4058

Search in DiVA

Show all publications