C++ (Cpp) __CS_pthread_mutex_unlock Beispiele

Beispiel #1

Datei: cs_time_var_mutex_true-unreach-call.c Projekt: Heizmann/sv-benchmarks

void *allocator()
{
    __CS_cs();
    if (__CS_ret != 0) return 0;
    __CS_pthread_mutex_lock(&m_inode[__CS_round]);
    __CS_cs();
    if (__CS_ret != 0) return 0;
    if (inode[__CS_round] == 0)
    {
        __CS_cs();
        if (__CS_ret != 0) return 0;
        __CS_pthread_mutex_lock(&m_busy[__CS_round]);
        __CS_cs();
        if (__CS_ret != 0) return 0;
        busy[__CS_round] = 1;
        __CS_cs();
        if (__CS_ret != 0) return 0;
        __CS_pthread_mutex_unlock(&m_busy[__CS_round]);
        __CS_cs();
        if (__CS_ret != 0) return 0;
        inode[__CS_round] = 1;
        __CS_cs();
        if (__CS_ret != 0) return 0;
    }
    __CS_cs();
    if (__CS_ret != 0) return 0;
    block[__CS_round] = 1;
    __CS_cs();
    if (__CS_ret != 0) return 0;
    if (!(block[__CS_round] == 1))
    {
        __CS_cs();
        if (__CS_ret != 0) return 0;
__CS_ERROR:
        __CS_error = 1;
        __CS_ret = __CS_ret_ERROR;
        return 0;
        __CS_cs();
        if (__CS_ret != 0) return 0;
        goto __CS_ERROR;

    }

    __CS_cs();
    if (__CS_ret != 0) return 0;
    ;
    __CS_cs();
    if (__CS_ret != 0) return 0;
    __CS_pthread_mutex_unlock(&m_inode[__CS_round]);
    __CS_cs();
    if (__CS_ret != 0) return 0;
    return 0;
    __CS_cs();
    if (__CS_ret != 0) return 0;
}

Beispiel #2

Datei: cs_stateful_false.c Projekt: jirislaby/svcomp

void *thread2(void *arg)
{
	__CS_cs(); if (__CS_ret != 0) return 0;
	__CS_pthread_mutex_lock(&ma[__CS_round]);
	__CS_cs(); if (__CS_ret != 0) return 0;
	data1[__CS_round] += 5;
	__CS_cs(); if (__CS_ret != 0) return 0;
	__CS_pthread_mutex_unlock(&ma[__CS_round]);
	__CS_cs(); if (__CS_ret != 0) return 0;
	__CS_pthread_mutex_lock(&ma[__CS_round]);
	__CS_cs(); if (__CS_ret != 0) return 0;
	data2[__CS_round] -= 6;
	__CS_cs(); if (__CS_ret != 0) return 0;
	__CS_pthread_mutex_unlock(&ma[__CS_round]);
	__CS_cs(); if (__CS_ret != 0) return 0;
}

Beispiel #3

Datei: cs_queue_true-unreach-call.c Projekt: oliverstth/sv-benchmarks

void *t1(void *arg)
{
	int value;
	int i;
	__CS_cs(); if (__CS_ret != 0) return 0;
	__CS_pthread_mutex_lock(&m[__CS_round]);
	__CS_cs(); if (__CS_ret != 0) return 0;
	if (enqueue_flag[__CS_round])
	{
		__CS_cs(); if (__CS_ret != 0) return 0;
		for (i = 0; i < 20; i++)
		{
			__CS_cs(); if (__CS_ret != 0) return 0;
			value = nondet_int();
			__CS_cs(); if (__CS_ret != 0) return 0;
			enqueue(&queue[__CS_round], value);
			__CS_cs(); if (__CS_ret != 0) return 0;
			stored_elements[__CS_round][i] = value;
			__CS_cs(); if (__CS_ret != 0) return 0;
		}
		__CS_cs(); if (__CS_ret != 0) return 0;
		enqueue_flag[__CS_round] = 0;
		__CS_cs(); if (__CS_ret != 0) return 0;
		dequeue_flag[__CS_round] = 1;
		__CS_cs(); if (__CS_ret != 0) return 0;
	}
	__CS_cs(); if (__CS_ret != 0) return 0;
	__CS_pthread_mutex_unlock(&m[__CS_round]);
	__CS_cs(); if (__CS_ret != 0) return 0;
	return 0;
	__CS_cs(); if (__CS_ret != 0) return 0;
}

Beispiel #4

Datei: cs_stack_true-unreach-call.c Projekt: Heizmann/sv-benchmarks

void *t2(void *arg)
{
	int i;
	__CS_cs(); if (__CS_ret != 0) return 0;
	for (i = 0; i < 5; i++)
	{
		__CS_cs(); if (__CS_ret != 0) return 0;
		__CS_pthread_mutex_lock(&m[__CS_round]);
		__CS_cs(); if (__CS_ret != 0) return 0;
		if (top[__CS_round] > 0)
		{
			__CS_cs(); if (__CS_ret != 0) return 0;
			if (pop(arr[__CS_round]) == (-2))
			{
				__CS_cs(); if (__CS_ret != 0) return 0;
				error();
			}

			__CS_cs(); if (__CS_ret != 0) return 0;
		}
		__CS_cs(); if (__CS_ret != 0) return 0;
		__CS_pthread_mutex_unlock(&m[__CS_round]);
		__CS_cs(); if (__CS_ret != 0) return 0;
	}
	__CS_cs(); if (__CS_ret != 0) return 0;
}

Beispiel #5

Datei: cs_stack_false-unreach-call.c Projekt: Heizmann/sv-benchmarks

void *t1(void *arg)
{
	int i;
	unsigned int tmp;
	__CS_cs(); if (__CS_ret != 0) return 0;
	for (i = 0; i < 5; i++)
	{
		__CS_cs(); if (__CS_ret != 0) return 0;
		__CS_pthread_mutex_lock(&m[__CS_round]);
		__CS_cs(); if (__CS_ret != 0) return 0;
		tmp = __VERIFIER_nondet_uint() % 5;
		__CS_cs(); if (__CS_ret != 0) return 0;
		if (push(arr[__CS_round], tmp) == (-1))
		{
			__CS_cs(); if (__CS_ret != 0) return 0;
			error();
		}

		__CS_cs(); if (__CS_ret != 0) return 0;
		flag[__CS_round] = 1;
		__CS_cs(); if (__CS_ret != 0) return 0;
		__CS_pthread_mutex_unlock(&m[__CS_round]);
		__CS_cs(); if (__CS_ret != 0) return 0;
	}
	__CS_cs(); if (__CS_ret != 0) return 0;
}

Beispiel #6

Datei: cs_queue_false.c Projekt: jirislaby/svcomp

void *t2(void *arg)
{
    int i;
    __CS_cs();
    if (__CS_ret != 0) return 0;
    for (i = 0; i < 20; i++)
    {
        __CS_cs();
        if (__CS_ret != 0) return 0;
        __CS_pthread_mutex_lock(&m[__CS_round]);
        __CS_cs();
        if (__CS_ret != 0) return 0;
        if (dequeue_flag[__CS_round])
        {
            __CS_cs();
            if (__CS_ret != 0) return 0;
            if ((!dequeue(&queue[__CS_round])) == stored_elements[__CS_round][i])
            {
                __CS_cs();
                if (__CS_ret != 0) return 0;
                goto __CS_ERROR;
                __CS_cs();
                if (__CS_ret != 0) return 0;
__CS_ERROR:
                __CS_error = 1;
                __CS_ret = __CS_ret_ERROR;
                return 0;
                __CS_cs();
                if (__CS_ret != 0) return 0;
                ;

                __CS_cs();
                if (__CS_ret != 0) return 0;
            }
            __CS_cs();
            if (__CS_ret != 0) return 0;
            dequeue_flag[__CS_round] = 0;
            __CS_cs();
            if (__CS_ret != 0) return 0;
            enqueue_flag[__CS_round] = 1;
            __CS_cs();
            if (__CS_ret != 0) return 0;
        }
        __CS_cs();
        if (__CS_ret != 0) return 0;
        __CS_pthread_mutex_unlock(&m[__CS_round]);
        __CS_cs();
        if (__CS_ret != 0) return 0;
    }
    __CS_cs();
    if (__CS_ret != 0) return 0;
    return 0;
    __CS_cs();
    if (__CS_ret != 0) return 0;
}

Beispiel #7

Datei: cs_sync_true-unreach-call.c Projekt: usefulalgorithm/sv-benchmarks

void *thread2(void *arg)
{
	__CS_cs(); if (__CS_ret != 0) return 0;
	__CS_pthread_mutex_lock(&m[__CS_round]);
	__CS_cs(); if (__CS_ret != 0) return 0;
	while (num[__CS_round] == 0)
	{
		__CS_cs(); if (__CS_ret != 0) return 0;
		__CS_pthread_cond_wait(&full[__CS_round], &m[__CS_round]);
	}

	__CS_cs(); if (__CS_ret != 0) return 0;
	num[__CS_round]--;
	__CS_cs(); if (__CS_ret != 0) return 0;
	__CS_pthread_mutex_unlock(&m[__CS_round]);
	__CS_cs(); if (__CS_ret != 0) return 0;
	__CS_pthread_cond_signal(&empty[__CS_round]);
	__CS_cs(); if (__CS_ret != 0) return 0;
}

Beispiel #8

Datei: cs_queue_false.c Projekt: jirislaby/svcomp

void *t1(void *arg)
{
    int value;
    int i;
    __CS_cs();
    if (__CS_ret != 0) return 0;
    __CS_pthread_mutex_lock(&m[__CS_round]);
    __CS_cs();
    if (__CS_ret != 0) return 0;
    value = nondet_int();
    __CS_cs();
    if (__CS_ret != 0) return 0;
    if (enqueue(&queue[__CS_round], value))
    {
        __CS_cs();
        if (__CS_ret != 0) return 0;
        goto __CS_ERROR;
        __CS_cs();
        if (__CS_ret != 0) return 0;
    }
    __CS_cs();
    if (__CS_ret != 0) return 0;
    stored_elements[__CS_round][0] = value;
    __CS_cs();
    if (__CS_ret != 0) return 0;
    if (empty(&queue[__CS_round]))
    {
        __CS_cs();
        if (__CS_ret != 0) return 0;
        goto __CS_ERROR;
        __CS_cs();
        if (__CS_ret != 0) return 0;
    }
    __CS_cs();
    if (__CS_ret != 0) return 0;
    __CS_pthread_mutex_unlock(&m[__CS_round]);
    __CS_cs();
    if (__CS_ret != 0) return 0;
    for (i = 0; i < (20 - 1); i++)
    {
        __CS_cs();
        if (__CS_ret != 0) return 0;
        __CS_pthread_mutex_lock(&m[__CS_round]);
        __CS_cs();
        if (__CS_ret != 0) return 0;
        if (enqueue_flag[__CS_round])
        {
            __CS_cs();
            if (__CS_ret != 0) return 0;
            value = nondet_int();
            __CS_cs();
            if (__CS_ret != 0) return 0;
            enqueue(&queue[__CS_round], value);
            __CS_cs();
            if (__CS_ret != 0) return 0;
            stored_elements[__CS_round][i + 1] = value;
            __CS_cs();
            if (__CS_ret != 0) return 0;
            enqueue_flag[__CS_round] = 0;
            __CS_cs();
            if (__CS_ret != 0) return 0;
            dequeue_flag[__CS_round] = 1;
            __CS_cs();
            if (__CS_ret != 0) return 0;
        }
        __CS_cs();
        if (__CS_ret != 0) return 0;
        __CS_pthread_mutex_unlock(&m[__CS_round]);
        __CS_cs();
        if (__CS_ret != 0) return 0;
    }
    __CS_cs();
    if (__CS_ret != 0) return 0;
    return 0;
    __CS_cs();
    if (__CS_ret != 0) return 0;
__CS_ERROR:
    __CS_error = 1;
    __CS_ret = __CS_ret_ERROR;
    return 0;
    __CS_cs();
    if (__CS_ret != 0) return 0;
    ;

    __CS_cs();
    if (__CS_ret != 0) return 0;
}