Worksharing Tasks: An Efficient Way to Exploit Irregular and FineGrained Loop Parallelism Shared memory programming models usually provide worksharing and task constructs. The former relies on the efficient forkjoin execution model to exploit structured parallelism; while the latter relies on finegrained synchronization among tasks and a flexible dataflow execution model to exploit dynamic, irregular, and nested parallelism. On applications that show both structured and unstructured parallelism, both worksharing and task constructs can be combined. However, it is difficult to mix both execution models without penalizing the dataflow execution model. Hence, on many applications structured parallelism is also exploited using tasks to leverage the full benefits of a pure dataflow execution model. However, task creation and management might introduce a nonnegligible overhead that prevents the efficient exploitation of finegrained structured parallelism, especially on manycore processors. In this work, we propose worksharing tasks. These are tasks that internally leverage worksharing techniques to exploit finegrained structured loopbased parallelism. The evaluation shows promising results on several benchmarks and platforms.

Synchronizing OnChip Software and Hardware Traces for HLSAccelerated Programs Complex designs generated from modern highlevel synthesis tools allow users to take advantage of heterogeneous systems, splitting the execution of programs between conventional processors, and hardware accelerators. While modern HLS tools continue to improve in efficiency and capability, debugging these designs has received relatively minor attention. Fortunately, recent academic work has provided the first means to debug these designs using hardware and software traces. Though these traces allow the user to analyze the flow of execution on both the software and hardware individually, they provide no means of synchronization to determine how operations on one device affect the other. We address this challenge by introducing a synchronization technique that keeps track of operations on shared objects. We identify objects shared between hardware and software and their memory operations, and use unique identifiers to synchronize the traces around these operations. We explore the added costs of this technique on execution time and hardware and software resources, and ways to reduce it through multiple synchronization schemes. This is demonstrated in an opensource prototype targeting the hybrid flow of the opensource HLStool LegUp.