Tasking support

[ramosian-glider]

Originally reported on Google Code with ID 37

Most modern concurrent software is built around the concept of "tasks" rather than raw
threads. Tsan could understand the concept of tasks natively. This would allow to (1)
print better reports (task creation stacks instead of thread creation stacks) and (2)
eliminate false negatives due to shared worker threads (a task is synchronized with
something just because a previous task on the same worked thread was synchronized with
that).

The proposed interface:
https://codereview.appspot.com/6904068/diff/6001/rtl/tsan_interface_task.h

Reported by dvyukov@google.com on 2013-11-14 07:14:08

[ramosian-glider]

see also https://code.google.com/p/address-sanitizer/issues/detail?id=142
We need to have it for all sanitizers

Reported by konstantin.s.serebryany on 2013-11-14 07:58:38

[ramosian-glider]

Seconding the feature request. Tasks would provide more informative messages about data
races between tasks executed in a thread pool.

Currently I can only see the place where the racy memory block was allocated, and the
places in the task that do conflicting accesses. However, tasks of the same type touching
the same memory block can be created in different places of the program. And finding
the place where the conflicting tasks are being added requires some kind of code bisection
or educated guessing and checking.

Reported by yegor.derevenets on 2014-05-28 08:54:01

[dvyukov]

The interface inline FTR:

//===-- tsan_interface_task.h -----------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file is a part of ThreadSanitizer (TSan), a race detector.
//
//===----------------------------------------------------------------------===//
#ifndef TSAN_INTERFACE_TASK_H
#define TSAN_INTERFACE_TASK_H

#ifndef INTERFACE_ATTRIBUTE
# define INTERFACE_ATTRIBUTE __attribute__((visibility("default")))
#endif

#ifdef __cplusplus
extern "C" {
#endif

// The tasking API is intended for programs that use finer-grained tasks
// on top of threads.  For such programs ThreadSanitizer can produce
// bad reports (namely, thread creation stack is useless), and catch less
// bugs because it does not understand task boundaries.
// The tasking API allows programs to annotate tasks to solve both problems.
// The API is intended to be flexible enough to support standard C++ tasks,
// OpenMP tasks as well as custom tasks.  It's also intended to be
// non-intrusive as possible to be used merely as annotations in existing code.

// Creation of a task.
// TASK is an arbitrary pointer that uniquely identifies the task.
// ThreadSanitizer stores any required internal info offline.
// FLAGS see below.
void INTERFACE_ATTRIBUTE __tsan_task_create(void *task, unsigned flags);

// Destruction of a task, frees all associated resources.
// After that the TASK pointer can be reused for another task.
void INTERFACE_ATTRIBUTE __tsan_task_destroy(void *task);

// Denotes beginning of execution of the TASK.
// When the function returns ThreadSanitizer effectively switches
// to another thread context associated with the task.
// Returns TASK.  This is needed because re-reading it even from stack variable
// can result in a data race with the worker thread (since we are already in the
// task context).
// Tasks can be recursive, but must be strictly nested.
void* INTERFACE_ATTRIBUTE __tsan_task_begin(void *task);

// Denotes end of execution of the TASK.
// When the function returns ThreadSanitizer effectively switches
// back to worker thread context.
void INTERFACE_ATTRIBUTE __tsan_task_end(void *task);

// If set, ThreadSanitizer uses separate thread context for task execution.
// If not set, ThreadSanitizer can not detect any new data races but still
// produces better reports (namely, task creation stack).  A user may not want
// to set in two cases:
// 1. If task executor executes tasks in single thread (and that is the part
//    of public contract).
// 2. If ThreadSanitizer produces false postives, but a user still wants
//    to take advantage of better reports.
const unsigned __TSAN_TASK_FLAG_SYNC = 1 << 0;

// Denotes that the task is periodic, i.e. can be executed several times
// (intended for periodic timer tasks and IO rediness notifications).
// If set, then __tsan_task_begin()/__tsan_task_end() can be called several
// times.
const unsigned __TSAN_TASK_FLAG_PERIODIC = 1 << 1;

// Usage examples:
/*
1. Non-periodic task:

void ThreadPool::Add(Task *t) {
  __tsan_task_create(t, __TSAN_TASK_FLAG_SYNC);
  mutex_.lock();
  queue_.push_back(t);
  mutex_.unlock();  
}

void ThreadPool::WorkerThread() {
  for (;;) {
    mutex_.lock();
    while (queue_.empty())
      convvar_.wait(&mutex_);
    Task *t = queue_.pop_front();    
    mutex_.unlock();
    t = __tsan_task_begin(t);
    t->Execute();
    __tsan_task_end(t);
    __tsan_task_destroy(t);
    delete t;
  }
}

This is semantically equivalent to:

void ThreadPool::Add(Task *t) {
  pthread_create(&t->thread_, 0, &Task::Execute, t);
}

2. Periodic task:

void ThreadPool::AddPeriodic(Task *t) {
  __tsan_task_create(t, __TSAN_TASK_FLAG_SYNC | __TSAN_TASK_FLAG_PERIODIC);
  AddPeriodicImpl(t, t->Period());
}

void ThreadPool::WorkerThread() {
  for (;;) {
    Task* t = CheckPeriodicTasks();
    if (t) {
      t = __tsan_task_begin(t);
      t->Execute();
      __tsan_task_end(t);
      AddPeriodicImpl(t, t->Period());
    }
    ...
  }
}

void ThreadPool::CancelPeriodic(Task *t) {
  CancelPeriodicImpl(t);
  __tsan_task_destroy(t);
  delete t;
}

This is semantically equivalent to:

void ThreadPool::Add(Task *t) {
  pthread_create(&t->thread_, 0, &ExecutePeriodic, t);
}

void *ExecutePeriodic(Task *t) {
  while (!t->Cancelled()) {
    sleep(t->Period());
    t->Execute();
  }
}

void ThreadPool::CancelPeriodic(Task *t) {
  t->SetCancelled();
  pthread_join(t->thread_, 0);
  delete t;
}
*/

#ifdef __cplusplus
}  // extern "C"
#endif

#undef INTERFACE_ATTRIBUTE

#endif  // #ifndef TSAN_INTERFACE_TASK_H