예제 #1
0
int ExecutionTracker::SimulateCondTimedwait(thrID myself, 
                void * ret_addr,
                pthread_cond_t * cond, 
                pthread_mutex_t * lock,
                const struct timespec * time) {
    glock();
    log->SimulateCondTimedwait(myself);
    checkCondValidity(cond);
    
    //unlock
    bool proceed = BeforeMutexUnlock(myself, ret_addr, lock, IS_COND_WAIT);
    safe_assert(proceed);
    safe_assert(Originals::pthread_mutex_unlock(lock) == OPERATION_SUCCESSFUL);
    AfterMutexUnlock(myself, ret_addr, OPERATION_SUCCESSFUL,lock,IS_COND_WAIT);
    
    
    cond_map[myself] = cond;
    handleSimulateCondTimedwait(myself, ret_addr, cond, lock);
    SchedPointInfo tmp(ret_addr, "Simulate Timed Wait (s)",
            myself, enable_map, IS_YIELD, cond, lock);
    schedule(&tmp);
    gunlock();

    waitPauseThread(myself);

    glock();
    cond_map[myself] = NULL;
    gunlock();

    //lock
    proceed = BeforeMutexLock(myself, ret_addr, lock, IS_COND_WAIT);
    safe_assert(proceed == false);
    signalThreadReady(myself);
    glock();
    bool was_signalled = was_signalled_map[myself];
    if (! was_signalled) {
        SchedPointInfo tmp(ret_addr, "Simulate Timed Wait (e)",
                myself, enable_map, IS_NOT_YIELD, cond, lock);
        schedule(&tmp);
        was_signalled_map[myself] = true;
    }
    gunlock();
    pauseThread(myself);
    SimulateMutexLock(myself, ret_addr, lock, IS_COND_WAIT);
    if (was_signalled) {
        log->timedwaitNoTimeout(myself);
        glock();
        gunlock();
        return OPERATION_SUCCESSFUL;
    } else {
        log->timedwaitTimeout(myself);
        glock();
        gunlock();
        return ETIMEDOUT;        
    }
}
예제 #2
0
void ExecutionTracker::myMemoryWrite(thrID myself, void * ret_addr,
        void * addr) {
    glock();
    log->myMemoryWrite(myself, addr);
    handleMyMemoryWrite(myself, ret_addr, addr);
    SchedPointInfo tmp(ret_addr, "Memory Write", myself,
            enable_map, IS_NOT_YIELD, addr);
    schedule(&tmp);
    gunlock();
    pauseThread(myself);
    glock();
    gunlock();
}
예제 #3
0
bool ExecutionTracker::BeforeBarrierWait(thrID myself, void * ret_addr,
        pthread_barrier_t * barrier) {
    glock();
    log->BeforeBarrierWait(myself);
    checkBarrierValidity(barrier);
    int target_count = bt->getBarrierCount(barrier);
    int threads_on_barrier = bt->getNumberThreadsWaitingOnBarrier(barrier);
    if (threads_on_barrier + 1 >= target_count) {
        vector<thrID> my_thr = bt->getThreadsWaitingOnBarrier(barrier);
        safe_assert(((unsigned) (my_thr.size() + 1)) 
                == (bt->getBarrierCount(barrier)));
        vector<thrID>::iterator itr;
        for (itr = my_thr.begin(); itr != my_thr.end(); itr++) {
            safe_assert(isDisabled((*itr)));
            enableThread((*itr));
        }
        enableThread(myself);
        bt->clearThreadsWaitingOnBarrier(barrier);
    } else {
        bt->threadWaitingOnBarrier(myself, barrier);
        disableThread(myself);
    }
    SchedPointInfo tmp(ret_addr, "Before Barrier Wait", myself,
            enable_map, IS_NOT_YIELD, barrier);
    schedule(&tmp);
    gunlock();
    pauseThread(myself);
    return false;
}
예제 #4
0
void ExecutionTracker::AfterMutexUnlock(thrID myself, 
        void * ret_addr,
        int ret_val, 
        pthread_mutex_t * lock,
        bool isWait) {
    if (!isWait) {
        glock(); 
    }

    /* Lock and unlocks get called when a thread is finishing up */
    if (threadIsFinished(myself)) {
        if (!isWait) {
            gunlock();
        }
        return;
    }
    log->AfterMutexUnlock(myself, isWait);
    threadHasReleasedLock(myself, lock);
    handleAfterMutexUnlock(myself, ret_addr, lock, isWait);
    if (! isWait) {
        SchedPointInfo tmp(ret_addr, "After Mutex Unlock", myself,
                enable_map, IS_NOT_YIELD, lock);
        schedule(&tmp);
        gunlock();
        pauseThread(myself); 
    }
}
예제 #5
0
bool ExecutionTracker::BeforeCondBroadcast(thrID myself, void * ret_addr,
        pthread_cond_t * cond) {
    glock();
    checkCondValidity(cond);
    gunlock();
    return false; 
}
예제 #6
0
bool ExecutionTracker::BeforeMutexLock(thrID myself, void * ret_addr,
        pthread_mutex_t * lock, bool isWait) {
    if (! isWait) {
        glock();
    }

    /* Lock and unlocks get called when a thread is finishing up */
    if (threadIsFinished(myself)) {
        if (! isWait) {
            gunlock();
        }
        return true;
    }
    log->BeforeMutexLock(myself, ret_addr, lock, isWait);
    determineLockStatus(myself, lock);
    handleBeforeMutexLock(myself, ret_addr, lock, isWait);
    if (! isWait) {
        SchedPointInfo tmp(ret_addr, "Before Mutex Lock", myself, 
                enable_map, IS_NOT_YIELD, lock);
        schedule(&tmp);
        gunlock();
        pauseThread(myself);
    }
    return false;
}
예제 #7
0
widget *new_toplevel_window(gui *_gui, int width, int height, char *title)
{
  struct gui *g = _gui;
  struct toplevel_window_widget *w;

  glock(g);

  w = new_widget(g, TOPLEVEL_WINDOW, sizeof(struct toplevel_window_widget));

  w->common.width  = width;
  w->common.height = height;

  w->x = x_create_window(g->x, width, height, title);

  w->common.repack    = repack;
  w->common.add_child = add_child;
  w->common.allocate  = allocate;
  w->common.paint     = paint;

  w->common.button    = button;

  gunlock(g);

  return w;
}
예제 #8
0
void
DjVuDebug::set_debug_file(FILE * file)
{
    GCriticalSectionLock glock(&debug_lock);
    if (debug_file && (debug_file != stderr))
        fclose(debug_file);
    debug_file = file;
}
예제 #9
0
void ExecutionTracker::SimulateExit(thrID myself, void * ret_addr,
        void * arg) {
    glock();
    log->SimulateExit(myself);
    finalizeThread(myself, ret_addr); 
    gunlock();
    Originals::pthread_exit(arg);
}
예제 #10
0
int ExecutionTracker::SimulateCondDestroy(thrID myself,
        void * ret_addr, pthread_cond_t * cond) {
    glock();
    cond_destroy.push_back(cond);
    int ret_val = Originals::pthread_cond_destroy(cond);
    gunlock();
    return ret_val;
}
예제 #11
0
int ExecutionTracker::SimulateMutexDestroy(thrID myself, void * addr,
        pthread_mutex_t * lock) {
    glock();
    mutex_destroy.push_back(lock);
    int ret_val = Originals::pthread_mutex_destroy(lock);
    gunlock();
    return ret_val;
}
예제 #12
0
void ExecutionTracker::ThreadFinish(thrID myself,
        void * (*start_routine) (void *), void * arg) {
    glock();
    log->ThreadFinish(myself, arg);
    finalizeThread(myself, reinterpret_cast<void *>(start_routine)); 
    lock_count--;
    Originals::pthread_mutex_unlock(global_lock);
}
예제 #13
0
void ExecutionTracker::ThreadStart(thrID myself,
        void * (*start_routine) (void *), void * arg) {
    glock();
    log->ThreadStart(myself, arg);
    handleThreadStart(myself, start_routine);
    gunlock();
    pauseThread(myself);
}
예제 #14
0
int ExecutionTracker::SimulateSemDestroy(thrID myself, void * ret_addr, 
        sem_t * sem) {
    glock();
    sem_destroy.push_back(sem);
    int ret_val = Originals::sem_destroy(sem);
    gunlock();
    return ret_val;
}
예제 #15
0
int ExecutionTracker::SimulateBarrierDestroy(thrID myself,
        void * ret_addr, pthread_barrier_t * barrier) {
    glock();
    barrier_destroy.push_back(barrier);
    int ret_val = Originals::pthread_barrier_destroy(barrier);
    gunlock();
    return ret_val;
}
예제 #16
0
void ExecutionTracker::thrilleCheckpoint(thrID myself, void * ret_addr) {
    glock();
    printf("Thrille: CHECKPOINT CALLED!\n");
    SchedPointInfo tmp(ret_addr, "Thrille Checkpoint", myself, 
            enable_map, IS_NOT_YIELD);
    schedule(&tmp);
    gunlock();
    pauseThread(myself);
    return;
}
예제 #17
0
bool ExecutionTracker::BeforeCondWait(thrID myself,
        void * ret_addr,
        pthread_cond_t * cond, 
        pthread_mutex_t * lock) {
    glock();
    log->BeforeCondWait(myself);
    disableThread(myself);
    gunlock();
    return false;
}
예제 #18
0
void ExecutionTracker::thrilleSchedPoint(thrID myself, void * ret_addr) {
    glock();
    log->BeforeSchedPoint(myself);
    safe_assert(isEnabled(myself));
    SchedPointInfo tmp(ret_addr, "Before Generic Schedule Point", myself,
            enable_map, IS_NOT_YIELD);
    schedule(&tmp);
    gunlock();
    pauseThread(myself);
}
예제 #19
0
void ExecutionTracker::scheduleThreadWaitingOnCond(thrID target,
        SignalPointInfo * s) {
    glock();
    safe_assert(s->cond_map[target] == s->cond);
    log->signalScheduling(target, s);
    wait_ready_map[target] = false;
    waitWakeThread(target);
    gunlock();
    waitThreadReady(s->thread, target);
}
예제 #20
0
int ExecutionTracker::SimulateSemWait(thrID myself, void * ret_addr,
        sem_t * sem) {
    glock();
    safe_assert(checkSemaphoreValue(sem) > 0);
    log->SimulateSemWait(myself);
    checkSemValidity(sem);
    int result = Originals::sem_wait(sem);
    threadHasPassedSemaphore(myself, sem);
    gunlock();
    return result;
}
예제 #21
0
int ExecutionTracker::SimulateMutexTrylock(thrID myself, void * ret_addr,
        pthread_mutex_t * lock) {
    glock();
    log->SimulateMutexTrylock(myself);
    int result = Originals::pthread_mutex_trylock(lock);
    if (result == OPERATION_SUCCESSFUL) {
        threadHasAcquiredLock(myself, lock);
    }
    gunlock();
    return result;
}
예제 #22
0
/* TODO: implement this */
bool ExecutionTracker::BeforeSigwait(thrID myself, void * ret_addr,
        const sigset_t * set, int * sig) {
    glock();
    disableThread(myself);
    SchedPointInfo tmp(ret_addr, "Before Sig Wait", myself, enable_map, false);
    schedule(&tmp);
    gunlock();
    bool sigwait_is_implemented = false;
    safe_assert(sigwait_is_implemented);
    return false;
}
예제 #23
0
bool ExecutionTracker::BeforeCondTimedwait(thrID myself, 
                void * ret_addr,
                pthread_cond_t * cond, 
                pthread_mutex_t * lock,
                const struct timespec * time) {
    glock();
    log->BeforeCondTimedwait(myself);
    enableThread(myself);
    gunlock();
    return false;
}
예제 #24
0
bool ExecutionTracker::BeforeBarrierInit(thrID myself, void * ret_addr,
        pthread_barrier_t * barrier, const pthread_barrierattr_t * battr,
        unsigned count) {
    glock();
    log->BeforeBarrierInit(myself);
    bt->initBarrier(barrier, count);
    barrierIsValid(barrier);
    gunlock();
    
    return true;
}
예제 #25
0
void ExecutionTracker::pauseThread(thrID target) {
    glock();
    sem_t * pause = sem_map[target];
    safe_assert(pause != NULL);
    log->pauseThread(target);
    gunlock();
    int result;
    do {
        result = Originals::sem_wait(pause);
    } while (result == -1 && errno == EINTR);
    safe_assert(result == OPERATION_SUCCESSFUL);
}
예제 #26
0
unsigned int ExecutionTracker::SimulateSleep(thrID myself, void * ret_addr,
        unsigned int time) {
    glock();
    log->mySleep(myself);
    handleMySleep(myself, ret_addr);
    SchedPointInfo tmp(ret_addr, "Simulate Sleep",
            myself, enable_map, IS_YIELD);
    schedule(&tmp);
    gunlock();
    pauseThread(myself);
    return OPERATION_SUCCESSFUL;
}
예제 #27
0
void ExecutionTracker::waitPauseThread(thrID target) {
    glock();
    sem_t * pause = wait_sem_map[target];
    safe_assert(pause != NULL);
    log->waitPauseThread(target);
    gunlock();
    int result;
    do {
        result = Originals::sem_wait(pause);
    } while (result == -1 && errno == EINTR);
    safe_assert(result == 0);
}
예제 #28
0
bool ExecutionTracker::BeforeCreate(thrID myself,
        thrID child,
        void * ret_addr,
        pthread_t * thread, 
        const pthread_attr_t * thread_attr,
        void *(* routine)(void *),
        void * arg) {
    glock();
    log->BeforeCreate(myself, child);
    initializeThreadData(child);
    gunlock();
    return true;
}
예제 #29
0
bool ExecutionTracker::BeforeMutexTrylock(thrID myself, void * ret_addr,
        pthread_mutex_t * lock) {
    glock();
    log->BeforeMutexTrylock(myself);
    enableThread(myself);
    handleBeforeMutexLock(myself, ret_addr, lock, IS_NOT_COND_WAIT);
    SchedPointInfo tmp(ret_addr, "Before Mutex Try Lock", myself, 
            enable_map, IS_NOT_YIELD, lock);
    schedule(&tmp);
    gunlock();
    pauseThread(myself);
    return false;
}
예제 #30
0
int ExecutionTracker::SimulateMutexLock(thrID myself, void * ret_addr,
        pthread_mutex_t * lock, bool isWait) {
    if (! isWait) {
        glock();
    }
    log->SimulateMutexLock(myself, isWait);
    threadHasAcquiredLock(myself, lock);
    int result = Originals::pthread_mutex_trylock(lock);
    if (! isWait) {
        gunlock();
    }
    return result;
}