Nº Máximo de Lugares

[Ca-moes]

Attempt nº1:
Arranjar formula que retorne o tamanho do array dado o nº de lugares.
Na verificação de lugar verifica os lugares até nplaces

• encontra lugar, soma e segue
• não encontra lugar, pôe variavel global a 1 a simbolizar que está à frente na lista de espera e espera até ter lugar livre

Nas outras threads que não encontrem lugar primeiro verificam a var global, se estiver a 1 esperam, se estiver a 0 pôem a 1 e procuram lugar
Actually, para verificar se tem lugar o programa está a usar mutexes: Podemos fazer com que fique sempre à procura de lugar dentro da secção critica do mutex caso não tenha um lugar disponivel na primeira passagem:

// Finding available place
    int tmp=0;
    if(pthread_mutex_lock(&mut)!=0){perror("Server-MutexLock");}
    while(TestBit(places,tmp)){tmp++;}
    place=tmp;
    SetBit(places, place);
    if(pthread_mutex_unlock(&mut)!=0){perror("Server-MutexUnLock");}

Assim outras threads têm de esperar que o mutex esteja desbloqueado para poderem verificar.
ERRO POSSIVEL : Assim que desbloqueia o mutex e estiver mais do que uma thread à espera não sei se entra uma e dá logo lock ou se pode entrar mais do que uma, vou testar e ver

---

Attempt 2
mudar para struct e fazer o que está no issue #42

---

Após estar a funcionar:

Usou-se a primeiro opção e tivemos a sorte de após um mutex dar unlock só uma thread é que entra

[filiperecharte]

a formula pode ser ceil(nplaces/32)

[Ca-moes]

1589032243 ; 12 ; 28839 ; 140318603183872 ; 972 ; 4 ; ENTER
1589032243 ; 19 ; 28840 ; 139963670099712 ; 562 ; -1 ; IWANT
1589032243 ; 19 ; 28839 ; 140318645147392 ; 562 ; -1 ; RECVD
1589032243 ; 12 ; 28840 ; 139963722651392 ; 972 ; 4 ; IAMIN
1589032243 ; 20 ; 28840 ; 139963722651392 ; 252 ; -1 ; IWANT
1589032243 ; 1 ; 28839 ; 140318742275840 ; 961 ; 1 ; TIMUP
1589032243 ; 13 ; 28839 ; 140318628361984 ; 265 ; 1 ; ENTER
1589032243 ; 13 ; 28840 ; 139963731044096 ; 265 ; 1 ; IAMIN
1589032243 ; 21 ; 28840 ; 139963731044096 ; 269 ; -1 ; IWANT
1589032243 ; 21 ; 28839 ; 140318742275840 ; 269 ; -1 ; RECVD
1589032243 ; 6 ; 28839 ; 140318636754688 ; 762 ; 5 ; TIMUP
1589032243 ; 14 ; 28839 ; 140318594791168 ; 602 ; 5 ; ENTER
1589032243 ; 2 ; 28839 ; 140318661932800 ; 990 ; 2 ; TIMUP
1589032243 ; 15 ; 28839 ; 140318586398464 ; 833 ; 2 ; ENTER
1589032244 ; 4 ; 28839 ; 140318653540096 ; 896 ; 3 ; TIMUP
1589032244 ; 16 ; 28839 ; 140318578005760 ; 358 ; 3 ; ENTER
1589032244 ; 14 ; 28840 ; 139963714258688 ; 602 ; 5 ; IAMIN
1589032244 ; 16 ; 28840 ; 139963695277824 ; 358 ; 3 ; IAMIN
1589032244 ; 22 ; 28840 ; 139963695277824 ; 850 ; -1 ; IWANT
1589032244 ; 22 ; 28839 ; 140318653540096 ; 850 ; -1 ; RECVD
1589032244 ; 15 ; 28840 ; 139963703670528 ; 833 ; 2 ; IAMIN

Este extrato é retirado duma parte final do programa. Ele tem muito IWANT RECVD juntos sem um ENTER a seguir porque fica no estado de procurar lugar então não consegue dar uma resposta imediata, mas assim que pode dar uma resposta de ENTER (que tem um TIMUP atrás) o IAMIN é imediato, ou seja, sempre está a entrar só uma thread na secção critica de cada vez. Nice

O problema que está a dar agora é isto:

1589032244 ; 17 ; 28840 ; 139963686885120 ; 946 ; -1 ; FAILD
1589032244 ; 25 ; 28840 ; 139963686885120 ; 45 ; -1 ; IWANT
1589032244 ; 8 ; 28839 ; 140318619969280 ; 869 ; 7 ; TIMUP
1589032244 ; 17 ; 28839 ; 140318569613056 ; 946 ; 7 ; ENTER

No programa dos clientes algumas threads não esperam o tempo suficiente e isso faz com que o programa quebre. Vou tentar tratar disto, pondo as threads a esperar como tempo máximo o tempo máximo de uso de um lugar.

[Ca-moes]

Alright, tendo agora na parte de leitura do fifo privado um usleep() a ter em conta o tempo maximo de uso (faz 5 tentativas de leitura, espera TIMEMAX/5 ms entre cada para no fim ter feito todas as tentativas e na ultima tem de haver 1 lugar livre caso o lugar ocupado tenha o usado durante o tempo maximo possivel).
Já aparecem os 2LATE's e CLOSD no final (also nice)

[Ca-moes]

Vou começar a tratar do README para ter isto despachado.
Os valores defaults para os argumentos, caso não sejam dados são:

• nthreads = INT_MAX -> aqui não tem problema pôr int max porque vai guardar um int, não importa se seja 1 ou 1000000 ocupa o mesmo espaço
• nplaces = 32 -> só 32? explicação: O tempo máximo de uso é 1000 ms e o intervalo entre cada pedido é de 50 ms, se olharmos para o pior caso (mais tempo de uso) teremos:
  • 0ms -> 1 pedido com 1000 ms
  • 50ms -> 1 pedido com 1000 ms, 950ms restantes no outro pedido
  • 100ms -> 1 a 1000ms, 1 a 950ms, 1 a 900ms
  • ...
    eventualmente vai chegar a um ponto em que vai haver 1 pedido a 50 ms (e os outros a +50ms cada um) e quando se passarem outros 50 ms, haverá outra vez 1 pedido a 50 ms e o número de pedidos em simultâneo não aumentará. Esse numero corresponde ao numero máximo possível de lugares ocupados em simultâneo, que é 1000/50 = 20. Ou seja, qualquer que sejam os valores de tempo de execução de U e Q, só estão, no máximo, 20 lugares a ser ocupados em simultâneo.
    Com isto, fica o valor default a 32 para ser mais fácil o calculo do ceil(32/32) e o array só terá tamanho 1.

[Ca-moes]

Com estas últimas mudanças passou a todos os testes e em geral parece bem, posso dar merge?