Blokada programu wykorzystującego zmienne warunkowe

Odpowiedz Nowy wątek
2015-01-23 11:02
0

Witam wszystkich, otóż próboję rozgryźć, dlaczego program blokuje się po pewnym czasie działania. Wątki nie kończą działania, więc powinny wykonywać się non stop. Blokade można zaobserwowąć po tym kiedy to wątek dojedzie do miasta, posiedzi w nim trochę i ustawia się w kolejce, w tym miejscu następuje blokada dla pewngo wątku, kilka poprzednich o dziwo działa bezproblemowo(?).

Polecenie:
Z miasta A do miasta B prowadzi droga, na której znajduje się wąski most umożliwiający tylko ruch jednokierunkowy.

  • Most jest również dość słaby, także może po nim przejeżdżać tylko jeden samochód na raz.
  • Napisać program w którym N samochodów (wątków) będzie nieustannie przejeżdżało z miasta do miasta, pokonując po drodze most (N przekazywane jako argument linii poleceń).
  • Zsynchronizuj dostęp wątków do mostu:
    a. nie wykorzystując zmiennych warunkowych (tylko mutexy/semafory)
    b .wykorzystując zmienne warunkowe (condition variables)
    Aby móc obserwować działanie programu, każdemu samochodowi przydziel numer. Program powinien wypisywać komunikaty według poniższego przykładu:

A-5 10>>> [>> 4 >>] <<<4 6-B
Oznacza to, że po stronie miasta A jest 15 samochodów

  • z czego 10 czeka w kolejce przed mostem,
  • przez most przejeżdża samochód z numerem 4 z miasta A do B,
  • po stronie miasta B jest 10 samochodów, z czego 4 oczekują w kolejce przed mostem.
  • Po uruchomieniu programu z parametrem -debug należy wypisywać całą zawartość kolejek po obu stronach mostu, nie tylko ilość samochodów.
  • Komunikat należy wypisywać w momencie, kiedy w programie zmieni się którakolwiek z tych wartości.

Uruchomienie programu: ./program -liczbaWatku

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <errno.h>
#include <string.h>

pthread_mutex_t most; // Zabezpiecza przejazd przez most tylko przez 1 samochod
pthread_mutex_t miasto; // Zabezpiecza zmienna wMiescieA
pthread_mutex_t miasto; // Zabezpiecza zmienna wMiescieB
pthread_mutex_t scrLock;
pthread_cond_t warKolejki = PTHREAD_COND_INITIALIZER;

int wKolejceA; // 0 - miasto A, 1 - miasto B
int wKolejceB;
int wMiescie[2]; // 0 - miasto A, 1 - miasto B
int *kolejkaA;
int *kolejkaB;

int ilWatkow = 0; // Zmienna zliczajaca ile watkow sie utworzylo
int lSamochodow = 0; // Zmienna przechowujaca liczbe samochodow z parametru
int trybDebug = 0; // 0 - brak, 1 - tryb debug

void wypiszKolejke(int miasto) {
    int i;
    if (miasto == 0) {
        printf("____Kolejka miasta A: ");
        for (i = 0; i < lSamochodow; i++)
            printf("%d ", kolejkaA[i]);
    } else if (miasto == 1) {
        printf("____Kolejka miasta B: ");
        for (i = 0; i < lSamochodow; i++)
            printf("%d ", kolejkaB[i]);
    }
}

int pierwszyWKolejce(int numerWatku, int miasto) {
    if (miasto == 0) {
        if (kolejkaA[0] == numerWatku) return 1;
        else return 0;
    } else {
        if (kolejkaB[0] == numerWatku) return 1;
        else return 0;
    }
}

int usunZKolejki(int numerWatku, int miasto) {
    int i = 0;
    if (miasto == 0) // A
    {
        if (kolejkaA[0] == numerWatku) {
            //Szukanie pierwszego wolnego indeksu, czyli kolejkaA[ind] = 0

            int indZero = 0;
            while (kolejkaA[indZero] != 0)
                indZero++;

            indZero--;
            while (i < lSamochodow - 1) {
                kolejkaA[i] = kolejkaA[i + 1];
                i++;
            }

            while (indZero < lSamochodow) {
                kolejkaA[indZero] = 0;
                indZero++;
            }
            printf("\nUsunieto samochod nr %d z kolejki miasta A", numerWatku);
            wypiszKolejke(miasto);
            return 1;
        } else {
            printf("\nSamochod ktory chesz usunac nie jest pierwszy!");
            return 0;
        }
    } else {
        if (kolejkaB[0] == numerWatku) {
            //Szukanie pierwszego wolnego indeksu, czyli kolejkaB[ind] = 0

            int indZero = 0;
            while (kolejkaB[indZero] != 0)
                indZero++;

            indZero--;

            while (i < lSamochodow - 1) {
                kolejkaB[i] = kolejkaB[i + 1];
                i++;
            }

            while (indZero < lSamochodow) {
                kolejkaB[indZero] = 0;
                indZero++;
            }
            printf("\nUsunieto samochod nr %d z kolejki miasta B", numerWatku);
            wypiszKolejke(miasto);
            return 1;
        } else {
            printf("\nSamochod ktory chesz usunac nie jest pierwszy!");
            return 0;
        }
    }
}

int dodajDoKolejki(int numerWatku, int miasto, int inicjuj) {
    if (miasto == 0) // A
    {
        int i = 0;
        while (kolejkaA[i] != 0) i++;
        kolejkaA[i] = numerWatku;

        if (inicjuj == 1)
            pthread_mutex_lock(&scrLock);
        printf("\nDodalo watek %d do kolejki miasta A", numerWatku);
        wypiszKolejke(miasto);
        if (inicjuj == 1)
            pthread_mutex_unlock(&scrLock);
        return 1;
    } else if (miasto == 1) {
        int i = 0;
        while (kolejkaB[i] != 0) i++;
        kolejkaB[i] = numerWatku;

        if (inicjuj == 1)
            pthread_mutex_lock(&scrLock);
        printf("\nDodalo watek %d do kolejki miasta B", numerWatku);
        wypiszKolejke(miasto);
        if (inicjuj == 1)
            pthread_mutex_unlock(&scrLock);
        return 1;
    } else {
        printf("\nBLAD DODAWANIA DO KOLEJKI");
        return 0; // Blad
    }

}

void jedzNaMiasto(int numerWatku, int miasto) {
    if (miasto == 0) {
        pthread_mutex_lock(&miasto);
        pthread_mutex_lock(&scrLock);
        wMiescie[0]++;
        printf("\nA-%d %d>>> [  BLANK  ] <<<%d %d-B", wMiescie[0], wKolejceA, wKolejceB, wMiescie[1]);

        wMiescie[0]--;
        printf("\nA-%d %d>>> [  BLANK  ] <<<%d %d-B", wMiescie[0], wKolejceA, wKolejceB, wMiescie[1]);
        wKolejceA++;
        dodajDoKolejki(numerWatku, miasto, 0);
        pthread_mutex_unlock(&miasto);
        printf("\nA-%d %d>>> [  BLANK  ] <<<%d %d-B", wMiescie[0], wKolejceA, wKolejceB, wMiescie[1]);
        pthread_cond_broadcast(&warKolejki);
        pthread_mutex_unlock(&scrLock);

        sleep(1);
        aDoB(numerWatku, miasto);
    } else {
        pthread_mutex_lock(&miasto);
        pthread_mutex_lock(&scrLock);
        wMiescie[1]++;
        printf("\nA-%d %d>>> [  BLANK  ] <<<%d %d-B", wMiescie[0], wKolejceA, wKolejceB, wMiescie[1]);

        wMiescie[1]--;
        printf("\nA-%d %d>>> [  BLANK  ] <<<%d %d-B", wMiescie[0], wKolejceA, wKolejceB, wMiescie[1]);
        wKolejceB++;
        dodajDoKolejki(numerWatku, miasto, 0);
        pthread_mutex_unlock(&miasto);
        printf("\nA-%d %d>>> [  BLANK  ] <<<%d %d-B", wMiescie[0], wKolejceA, wKolejceB, wMiescie[1]);
        pthread_cond_broadcast(&warKolejki);
        pthread_mutex_unlock(&scrLock);

        sleep(1);
        bDoA(numerWatku, miasto);
    }
}

void aDoB(int numerWatku, int miasto) {
    pthread_mutex_lock(&most);
    do {
        if (pierwszyWKolejce(numerWatku, miasto) == 1) {
            pthread_mutex_lock(&miasto);
            pthread_mutex_lock(&scrLock);
            wKolejceA--;
            usunZKolejki(numerWatku, miasto);
            pthread_mutex_unlock(&miasto);
            printf("\nA-%d %d>>> [  BLANK  ] <<<%d %d-B", wMiescie[0], wKolejceA, wKolejceB, wMiescie[1]);

            printf("\nA-%d %d>>> [>>  %d  >>] <<<%d %d-B", wMiescie[0], wKolejceA, numerWatku, wKolejceB, wMiescie[1]);
            pthread_mutex_unlock(&scrLock);
            break;
        } else
            pthread_cond_wait(&warKolejki, &most);
    } while (1);
    pthread_mutex_unlock(&most);

    sleep(1);
    jedzNaMiasto(numerWatku, 1);
}

void bDoA(int numerWatku, int miasto) {
    pthread_mutex_lock(&most);
    do {
        if (pierwszyWKolejce(numerWatku, miasto) == 1) {
            pthread_mutex_lock(&miasto);
            pthread_mutex_lock(&scrLock);
            wKolejceB--;
            usunZKolejki(numerWatku, miasto);
            pthread_mutex_unlock(&miasto);
            printf("\nA-%d %d>>> [  BLANK  ] <<<%d %d-B", wMiescie[0], wKolejceA, wKolejceB, wMiescie[1]);

            printf("\nA-%d %d>>> [<<  %d  <<] <<<%d %d-B", wMiescie[0], wKolejceA, numerWatku, wKolejceB, wMiescie[1]);
            pthread_mutex_unlock(&scrLock);
            break;
        } else
            pthread_cond_wait(&warKolejki, &most);
    } while (1);

    pthread_mutex_unlock(&most);

    sleep(1);
    jedzNaMiasto(numerWatku, 0);
}

int losujMiasto() {
    int losowa = rand() % 100;

    if (losowa % 2 == 0) {
        return 0; // Miasto A
    } else {
        return 1; // Miasto B
    }
}

void *inicjujWatek(int numerWatku) //DOdaj inny mutex zamiast obecnych
{
    int losoweMiasto = losujMiasto();

    if (losoweMiasto == 0) {
        pthread_mutex_lock(&miasto);
        wKolejceA++;
        dodajDoKolejki(numerWatku, losoweMiasto, 1);
        pthread_mutex_unlock(&miasto);
        while (ilWatkow < lSamochodow);
        aDoB(numerWatku, losoweMiasto);
    }
    else if (losoweMiasto == 1) {
        pthread_mutex_lock(&miasto);
        wKolejceB++;
        dodajDoKolejki(numerWatku, losoweMiasto, 1);
        pthread_mutex_unlock(&miasto);
        while (ilWatkow < lSamochodow);
        bDoA(numerWatku, losoweMiasto);
    }

}

void utworzWatki() {
    pthread_t samochod[lSamochodow];
    int i;
    for (i = 0; i < lSamochodow; i++) {
        int wynik = pthread_create(&samochod[i], NULL, &inicjujWatek, (void *) i + 1); //!!!!!!!!!!!!!
        if (wynik != 0) printf("Nie powiodło się pthread_create\n");
        else ilWatkow++;
    }

    for (i = 0; i < lSamochodow; i++) {
        pthread_join(samochod[i], NULL);
    }
}

void ilSamochodow(char *arg) // Parsuje liczbe samochodow z parametru
{
    int rozmiarArg = 1;
    while (arg[rozmiarArg] != '\0') {
        rozmiarArg++;
    }

    char temp[rozmiarArg];
    int indArg = 1;
    int indTemp = 0;
    for (indArg = 1; indArg < rozmiarArg; indArg++) {
        temp[indTemp] = arg[indArg];
        indTemp++;
    }
    temp[indTemp] = '\0';

    lSamochodow = atoi(temp);
    printf("\nLiczba samochodow z parametru = %d", lSamochodow);
}

void sprDebug(int argc, char **argv) // Sprawdza czy podano parametr -debug
{
    if (argc > 2) {
        if (strcmp(argv[2], "-debug") == 0) {
            trybDebug = 1;
            printf("\nTryb debug");
        }
    }
}

void zerowanieZmiennych() {
    wKolejceA = 0;
    wKolejceB = 0;
    wMiescie[0] = 0;
    wMiescie[1] = 0;

    int i;
    for (i = 0; i < lSamochodow; i++) {
        kolejkaA[i] = 0;
        kolejkaB[i] = 0;
    }
}

int main(int argc, char **argv) {
    printf("KOMPILACJA: gcc -o most most2.c -lpthread");
    printf("\nUruchamianie: ./most -N -debug");

    pthread_mutex_init(&most, NULL);
    pthread_mutex_init(&miasto, NULL);
    //pthread_mutex_init(&miasto, NULL);
    pthread_mutex_init(&scrLock, NULL);
    int kolejkawA[lSamochodow];
    int kolejkawB[lSamochodow];
    kolejkaA = kolejkawA;
    kolejkaB = kolejkawB;

    ilSamochodow(argv[1]);
    zerowanieZmiennych();
    sprDebug(argc, argv);
    utworzWatki();

    return 0;
}
edytowany 5x, ostatnio: N3rvous, 2015-01-23 15:26

Pozostało 580 znaków

2015-01-23 13:04
1

dlaczego program blokuje się po pewnym czasie działania

Szklana kula mówi: bo zawaliłeś synchronizacje i masz gdzieś deadlocka/zagłodzenie.


Masz problem? Pisz na forum, nie do mnie. Nie masz problemów? Kup komputer...

Pozostało 580 znaków

2015-01-23 13:27
0

Analizowałem kod juz kilka razy i według mnie deadlocka nie ma. Zaktalizowałem kod.

Pozostało 580 znaków

2015-01-23 14:05
tr
0

Jeśli lockujesz w kolejności

  1. miasto
  2. scrLock

To powinieneś odblokowywać w kolejności odwrotnej, czyli

  1. scrLock
  2. miasto

Ty tak nie masz, dlatego występuje deadlock.

Niekoniecznie. Ważne jest lockowanie w zadanej kolejności. Gdyby potem gdzieś lockował odwrotnie, tzn najpierw scrLock a potem miasto to jasne że byłby deadlock, ale nigdy w tym kodzie tak nie jest. Zawsze przed lockowaniem scrLock wątek ma miasto. - Shalom 2015-01-23 14:18

Pozostało 580 znaków

2015-01-23 14:16
1

Wątpię żebyś coś znalazł go kod to totalnie spaghetti, a niestety deadlocków w takim kodzie szuka się raczej trudno. Skoro program sie blokuje to jakiś deadlock jest, innej rady nie ma :)
Z dziwnych rzeczy które tu widzę: masz jakieś dziwne "szukanie indZero" które potem nigdzie nie jest używane. Poza tym nie zauważyłem żebyś kiedykolwiek zerował te wartości podczas "usuwania z kolejki". Ot przesuwasz je sobie do tyłu żeby usunąć pierwszy element, ale nigdzie nie wpisujesz 0 chyba ze coś przeoczyłem. W efekcie jak masz np.

1 2 3 4 5 0 0 i usuwasz pierwszy element to dostajesz
2 3 4 5 5 0 0 a chyba nie o to chodziło...


Masz problem? Pisz na forum, nie do mnie. Nie masz problemów? Kup komputer...

Pozostało 580 znaków

2015-01-23 14:26
1

chłopaku sleep w mutexie to jeden z nawiększych grzechów programisty, fixnij to najpierw

edit
i poczytaj w necie co się z tym wiąże

edytowany 1x, ostatnio: gośćabc, 2015-01-23 14:30

Pozostało 580 znaków

2015-01-23 15:25
0

@Shalom Rzeczywiście zapomniałem kawałek kodu dokleić :P już mózg słabo pracuje. Dokleiłem, ale coś dalej kolejki mnie w konia robią ;/

@gośćabc Trochę poczytałem :) przeniosłem je poza zakres lock - unlock.

Znowu zaktualizowalem kod. Kod już nie staje w miejscu, ale program nie działa. Kolejki tak jak by niepoprawnie dodają i usuwają,</del>

Zaczynam pisać od nowa. Poprawienie tego przerasta mnie i moje zasoby czasowe oraz chęci.

edytowany 3x, ostatnio: N3rvous, 2015-01-23 18:56
loguj stany i zobacz co nie działa - gośćabc 2015-01-23 17:10

Pozostało 580 znaków

Odpowiedz
Liczba odpowiedzi na stronę

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0