Researcher:
Mutlu, Erdal

Profile Picture
ORCID

Job Title

PhD Student

First Name

Erdal

Last Name

Mutlu

Name

Name Variants

Mutlu, Erdal

Email Address

Birth Date

Filters

2014 - 20185

Advanced Search

Filter by

Settings

Researcher Of Publications: search.filters.isAuthorOfPublication.91499167-a25a-4ef3-96f6-14928453f3ec

Search Results

Now showing 1 - 5 of 5
  • Placeholder
    PublicationMetadata only
    Towards verifying eventually consistent applications
    (Association for Computing Machinery, 2014) N/A; N/A; N/A; Department of Computer Engineering; Özkan, Burcu Külahcıoğlu; Mutlu, Erdal; Taşıran, Serdar; PhD Student; PhD Student; Faculty Member; Department of Computer Engineering; Graduate School of Sciences and Engineering; Graduate School of Sciences and Engineering; College of Engineering; N/A; N/A; N/A
    N/A
  • Placeholder
    PublicationMetadata only
    Detecting Javascript races that matter
    (Assoc Computing Machinery, 2015) Livshits, Benjamin; N/A; Department of Computer Engineering; Mutlu, Erdal; Taşıran, Serdar; PhD Student; Faculty Member; Department of Computer Engineering; Graduate School of Sciences and Engineering; College of Engineering; N/A; N/A
    As JavaScript has become virtually omnipresent as the language for programming large and complex web applications in the last several years, we have seen an increase in interest in finding data races in client-side JavaScript. While JavaScript execution is single-threaded, there is still enough potential for data races, created largely by the non-determinism of the scheduler. Recently, several academic efforts have explored both static and run-time analysis approaches in an effort to find data races. However, despite this, we have not seen these analysis techniques deployed in practice and we have only seen scarce evidence that developers find and fix bugs related to data races in JavaScript. In this paper we argue for a different formulation of what it means to have a data race in a JavaScript application and distinguish between benign and harmful races, affecting persistent browser or server state. We further argue that while benign races — the subject of the majority of prior work — do exist, harmful races are exceedingly rare in practice (19 harmful vs. 621 benign). Our results shed a new light on the issues of data race prevalence and importance. To find races, we also propose a novel lightweight run-time symbolic exploration algorithm for finding races in traces of run-time execution. Our algorithm eschews schedule exploration in favor of smaller run-time overheads and thus can be used by beta testers or in crowd-sourced testing. In our experiments on 26 sites, we demonstrate that benign races are considerably more common than harmful 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
    I know it when i see it: observable races in JavaScript applications
    (Association for Computing Machinery (ACM), 2014) Livshits, Benjamin; N/A; Department of Computer Engineering; Mutlu, Erdal; Taşıran, Serdar; PhD Student; Faculty Member; Department of Computer Engineering; Graduate School of Sciences and Engineering; College of Engineering; N/A; N/A
    Despite JavaScript runtime's lack of conventional threads, the presence of asynchrony creates a real potential for concurrency errors. These concerns have lead to investigations of race conditions in the Web context. However, focusing on races does not produce actionable error reports that would at the end of the day appeal to developers and cause them to fix possible underlying problems. In this paper, we advocate for the notion of observable races, focusing on concurrency conditions that lead to visually apparent glitches caused by non-determinism within the runtime scheduler on the network. We propose and investigate ways to find observable races via systematically exploring possible network schedules and shepherding the scheduler towards correct executions. We propose crowd-sourcing both to spot when different schedules lead to visually broken sites and also to determine under what environment conditions (OS, browser, network speed) these schedules may in fact happen in practice for some fraction of the users.
  • Placeholder
    PublicationMetadata only
    Dynamic verification for hybrid concurrent programming models
    (Springer Int Publishing Ag, 2014) Gajinov, Vladimir; Cristal, Adrian; Unsal, Osman S.; N/A; Department of Computer Engineering; Mutlu, Erdal; Taşıran, Serdar; PhD Student; Faculty Member; Department of Computer Engineering; Graduate School of Sciences and Engineering; College of Engineering; N/A; N/A
    We present a dynamic verification technique for a class of concurrent programming models that combine dataflow and shared memory programming. In this class of hybrid concurrency models, programs are built from tasks whose data dependencies are explicitly defined by a programmer and used by the runtime system to coordinate task execution. Differently from pure dataflow, tasks are allowed to have shared state which must be properly protected using synchronization mechanisms, such as locks or transactional memory (TM). While these hybrid models enable programmers to reason about programs, especially with irregular data sharing and communication patterns, at a higher level, they may also give rise to new kinds of bugs as they are unfamiliar to the programmers. We identify and illustrate a novel category of bugs in these hybrid concurrency programming models and provide a technique for randomized exploration of program behaviors in this setting.