Researcher:
Matar, Hassan Salehe

Profile Picture
ORCID

Job Title

PhD Student

First Name

Hassan Salehe

Last Name

Matar

Name

Name Variants

Matar, Hassan Salehe

Email Address

Birth Date

Filters

2013 - 20184

Advanced Search

Filter by

Settings

Researcher Of Publications: search.filters.isAuthorOfPublication.dc547bf6-7324-4411-b801-47bf4d7af8e4

Search Results

Now showing 1 - 4 of 4
  • Placeholder
    PublicationMetadata only
    PaRV: parallelizing runtime detection and prevention of concurrency errors
    (Springer, 2013) Cristal, Adrian; Kestor, Gokcen; Unsal, Osman; N/A; N/A; Kuru, İsmail; Matar, Hassan Salehe; PhD Student; PhD Student; Graduate School of Sciences and Engineering; Graduate School of Sciences and Engineering; N/A; N/A
    We present the PaRV tool for runtime detection of and recovery from data races in multi-threaded C and C++ programs. PaRV uses transactional memory technology for parallelizing runtime verification and for buffering write accesses during race checking. Application threads are slowed down only due to instrumentation, but not due to the computation performed by runtime verification algorithms since the latter are run concurrently on different threads. Buffering writes allows us to recover from races and to safeguard against later ones.
  • Placeholder
    PublicationMetadata only
    Output nondeterminism detection for programming models combining dataflow with shared memory
    (Elsevier Science Bv, 2018) N/A; N/A; N/A; Department of Computer Engineering; Department of Computer Engineering; Matar, Hassan Salehe; Mutlu, Erdal; Taşıran, Serdar; Erten, Didem Unat; PhD Student; PhD Student; Faculty Member; Faculty Member; Department of Computer Engineering; Graduate School of Sciences and Engineering; Graduate School of Sciences and Engineering; College of Engineering; College of Engineering; N/A; N/A; N/A; 219274
    Implementing highly concurrent programs can be challenging because programmers can easily introduce unintended nondeterminism, which has the potential to affect the program output. We propose and implement a technique for detecting unintended nondeterminism in applications developed on shared memory systems with dataflow execution model. Such nondeterminism bugs may be caused by missing or incorrect ordering of task dependencies that are used for ensuring certain ordering of tasks. The proposed method is based on the formulation of happens-before relation on tasks executions in a dataflow dependency graph. Its implementation is composed of two main phases; log recording and detection. For recording the necessary information from the execution, the tool instruments the dataflow framework and the applications, on top of the LLVM compiler infrastructure. Later it processes the collected log and reports on the found output nondeterminism in the execution. The tool can integrate well with the development cycle to provide the programmer with a testing framework against possible nondeterminism bugs. To demonstrate its effectiveness, we study a set of benchmark applications written in Atomic DataFlow programming model and report on real nondeterminism bugs in them.
  • Placeholder
    PublicationMetadata only
    Runtime determinacy race detection for openMP tasks
    (Springer International Publishing Ag, 2018) N/A; N/A; Department of Computer Engineering; Matar, Hassan Salehe; Erten, Didem Unat; PhD Student; Faculty Member; Department of Computer Engineering; Graduate School of Sciences and Engineering; College of Engineering; N/A; 219274
    One potential problem when writing parallel programs with OpenMP is to introduce determinacy races where for a given input, the program may unexpectedly produce different final outputs at different runs. Such startling behavior can result from incorrect ordering of OpenMP tasks. We present a method to detect determinacy races in OpenMP tasks at runtime. Based on OpenMP program semantics, our proposed solution models an OpenMP program as a collection of tasks with inferred dependencies among them where a task is implicitly created with a parallel region construct or explicitly created with a task construct. We define happens-before relation among tasks based on such dependencies for determining an execution order when detecting determinacy races. Based on this formalization, we developed a tool, TaskSanitizer, which detects and reports concurrent memory accesses whose tasks do not have common dependencies. Finally, TaskSanitizer works at runtime, has been able to find bugs in micro-benchmarks and it is reasonably efficient to be utilized in a working environment.
  • Thumbnail Image
    PublicationOpen Access
    EmbedSanitizer: runtime race detection tool for 32-bit embedded ARM
    (Springer, 2017) Department of Computer Engineering; Matar, Hassan Salehe; Taşıran, Serdar; Erten, Didem Unat; PhD Student; Faculty Member; Faculty Member; Department of Computer Engineering; College of Engineering; N/A; N/A; 219274
    We propose EmbedSanitizer, a tool for detecting concurrency data races in 32-bit ARM-based multithreaded C/C++ applications. Moreover, we motivate the idea of detecting data races in embedded systems software natively; without virtualization or emulation or use of alternative architecture. Detecting data races in applications on a target hardware provides more precise results and increased throughput and hence enhanced developer productivity. EmbedSanitizer extends ThreadSanitizer, a race detection tool for 64-bit applications, to do race detection for 32-bit ARM applications. We evaluate EmbedSanitizer using PARSEC benchmarks on an ARMv7 CPU with 4 logical cores and 933 MB of RAM. Our race detection results precisely match with results when the same benchmarks run on 64-bit machine using ThreadSanitizer. Moreover, the performance overhead of EmbedSanitizer is relatively low as compared to running race detection on an emulator, which is a common platform for embedded software development.