int sthread_cond_wait(sthread_cond_t *cond, sthread_mutex_t *mutex)
{
if(cond->cond) {
__DEBUG_PRINT(("tid %d cond 1 \n", __selftid));
setup_sync();
wait_to_enter();
__DEBUG_PRINT(("tid %d cond 2 \n", __selftid));
// if(__threadpool[])
v_next_mutex(mutex->mutex);
__threadpool[__selftid].mutex = NULL;
__mvspace_commit();
__threadpool[__selftid].state = E_STOPPED;
__threadpool[__selftid].cond = cond->cond;
__DEBUG_PRINT(("tid %d cond 3 \n", __selftid));
v_next_and_wait();
__DEBUG_PRINT(("tid %d cond 4 \n", __selftid));
__mvspace_pull();
__DEBUG_PRINT(("tid %d cond 5 \n", __selftid));
wait_sem(cond->cond->locks, __selftid);
__threadpool[__selftid].mutex = mutex->mutex;
__DEBUG_PRINT(("tid %d cond 5.5 \n", __selftid));
wait_sem(mutex->mutex->locks, __selftid);
__threadpool[__selftid].state = E_NORMAL;
__DEBUG_PRINT(("tid %d cond 6 \n", __selftid));
leave_sync();
return 0;
}
return -1;
}
IMAGELIB_ERROR_CODE imagelib_get_frame_data_asyn(IMAGELIB_SESSION*_session,IMAGELIB_RECT _src_rect,
INT32 _dest_width,INT32 _dest_height, IMAGELIB_EFFECT_PARA _effect_para,DECODE_FRAME_ENDING_CB cb )
{
IMAGE_INSTANCE *decoder_instance,*encoder_instance=NULL;
IMAGELIB_MSG_PARA_LIST* para_list = NULL;
if(_session == NULL || _session->instance_p == NULL)
{
return IMAGELIB_RAM_EXECPTION;
}
wait_sem(_session->decode_sem);
if(_session ->state == IMAGELIB_DECODING)
{
signal_sem(_session->decode_sem);
return IMAGELIB_CURRENT_SESSION_BUSY;
}
decoder_instance = _session->instance_p;
_session->error_code= image_open_dev_by_imagedata("rab",NULL, 0,&encoder_instance);
if(_session->error_code != IMAGELIB_SUCCESS || encoder_instance==NULL)
{
signal_sem(_session->decode_sem);
return _session->error_code;
}
_session ->state = IMAGELIB_DECODING;
para_list = imagelib_copy_msg_paralist(IMAGELIB_GETFRAMEDATA_MSG,_session,decoder_instance,encoder_instance,_src_rect,_dest_width,_dest_height,_effect_para,cb);
if(para_list==NULL)
return IMAGELIB_RAM_EXECPTION;
imagelib_postworkmessage(¶_list);
signal_sem(_session->decode_sem);
return _session->error_code;
}
IMAGELIB_ERROR_CODE imagelib_save_frame_to_file_asyn(IMAGELIB_SESSION*_session,IMAGELIB_RECT _src_rect,
const WCHAR* _dest_pathname,INT32 _dest_width,INT32 _dest_height,
IMAGELIB_EFFECT_PARA _effect_para,DECODE_FRAME_ENDING_CB cb)
{
IMAGE_INSTANCE *decoder_instance,*encoder_instance=NULL;
IMAGELIB_MSG_PARA_LIST* para_list = NULL;
char utf_pathname[UTA_MAX_PATHNAME_LEN*2+1];
if(_session == NULL || _session->instance_p == NULL)
{
return IMAGELIB_RAM_EXECPTION;
}
wait_sem(_session->decode_sem);
if(_session ->state == IMAGELIB_DECODING)
{
signal_sem(_session->decode_sem);
return IMAGELIB_CURRENT_SESSION_BUSY;
}
decoder_instance = _session->instance_p;
UnicodeToUtf8(utf_pathname,_dest_pathname);
_session->error_code=image_open_by_filename(utf_pathname, "wb",NULL,&encoder_instance);
if(_session->error_code != IMAGELIB_SUCCESS || encoder_instance==NULL)
{
signal_sem(_session->decode_sem);
return _session->error_code;
}
_session ->state = IMAGELIB_DECODING;
para_list = imagelib_copy_msg_paralist(IMAGELIB_SAVEFRAMEDATA_MSG,_session,decoder_instance,encoder_instance,_src_rect,_dest_width,_dest_height,_effect_para,cb);
imagelib_postworkmessage(¶_list);
signal_sem(_session->decode_sem);
return _session->error_code;
}
int main (int argc,char* argv[])
{
//main ss
int semid,shmid;
char *shmaddr;
char write_str[SHM_SIZE];
memset(write_str,SHM_SIZE,'\0');
if ((shmid = createshm(".",'m',SHM_SIZE)) == -1) {
exit(-1);
}
if((shmaddr = shmat(shmid,(char*)0,0)) == (char*)-1)
{
cout << "shmat error" << endl;
}
if((semid =(createsem(".",'s',1,1)))==-1)
{
exit(-1);
}
while(1)
{
wait_sem(semid,0);
sem_P(semid,0);
cout << "writer:"<< "do something here" << endl;
fgets(write_str,1024,stdin);
int length = strlen(write_str);
write_str[len]='\0';
strncpy(shmaddr,write_str,len+1);
sleep(10);
}
return 0;
}
// monitor takes a function pointer (function w/ int as parameter)
// and an int to run with the function pointer
void enter_monitor(int proc_num, int shm_id, void (*enter_cs)(int)) {
time_t tcurrent;
struct tm *timeinfo;
cond_t *cond;
cond = shmat(shm_id,0,0);
wait_sem(cond->sem_id,0); // mutex.wait() - wait for free critical section
wait_cond(cond);
time(&tcurrent);
timeinfo = localtime(&tcurrent);
fprintf(stderr, "Process %d entering critical section at %d:%02d:%02d\n",
proc_num,timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
// execute the function sent to the monitor
(*enter_cs)(proc_num);
time(&tcurrent);
timeinfo = localtime(&tcurrent);
fprintf(stderr, "Process %d exiting critical section at %d:%02d:%02d\n",
proc_num,timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
if (cond->next_count > 0) {
signal_sem(cond->sem_id,1); // next.signal();
signal_cond(cond);
} else {
signal_cond(cond);
}
signal_sem(cond->sem_id,0); // done with critical section
shmdt(cond);
}
int main()
{
int i,pid,child,sem;
key_t sem_key;
pid = getpid();
printf("Soy el padre y mi PID es %d\n", pid);
sem_key = ftok("/bin/ls", 42);
sem = semget(sem_key, 1, IPC_CREAT|0600);
if (sem < 0) {
perror("semget");
exit(1);
}
for (i=0; i<10; i++) {
child = fork();
if (child == -1) {
perror("fork");
}
if (child == 0) { //CHILD
pid = getpid();
printf("Soy un hijo y mi PID es %d\n", pid);
signal_sem(sem);
exit(0);
} else { //PARENT
wait_sem(sem);
printf("Continuacion del padre\n", pid);
}
}
exit(0);
}
int main()
{
int i, shmid;
int semid;
int jugadorX = 0;
int jugadorO = 0;
bool *continuar;
int *tab;
llave_semaforo();
llave_memoria();
reiniciar_juego(&tab,&semid,&shmid);
//Se utiliza continuar como bandera para saber cuando terminar el proceso O
//continuar apunta a una casilla extra del arreglo del tablero de juego.
continuar = &tab[(TAM*TAM)+1];
system("clear");
//Se bloquea a O en espera de X
wait_sem(semid,jugadorO);
while((*continuar))
{
system("clear");
imprimir(&tab);
jugar(&tab);
system("clear");
//Se despierta a X
signal_sem(semid,jugadorX);
//Se bloquea a O
wait_sem(semid,jugadorO);
}
return 0;
}
T front()
{
sem_t *p_sem;
T ret;
p_sem = &this->p_sem;
// 等待信号量
if(0 != wait_sem(p_sem)) {
perror("wait a sem");
exit(1);
}
if (!mQueue.empty()) {
ret = mQueue.front();
mQueue.pop();
}
// throw exception
return ret;
};
int sthread_barrier_wait(sthread_barrier_t *barrier)
{
if(barrier->barrier) {
setup_sync();
//setup_barrier_sync(barrier->barrier);
__DEBUG_PRINT(("tid %d barrier1\n", __selftid));
wait_to_enter();
__mvspace_commit();
__threadpool[__selftid].state = E_STOPPED;
__threadpool[__selftid].barrier = barrier->barrier;
__DEBUG_PRINT(("tid %d barrier2\n", __selftid));
v_next_and_wait();
setup_barrier_sync(barrier->barrier);
__sync_fetch_and_add(&(barrier->barrier->num), 1);
__DEBUG_PRINT(("tid %d barrier3\n", __selftid));
__mvspace_pull();
if(barrier->barrier->total == barrier->barrier->num) {
int i;
for(i=0;i<MAXTHREADS;i++) {
if(__threadpool[i].barrier == barrier->barrier)
__threadpool[i].state = E_NORMAL;
}
__DEBUG_PRINT(("tid %d barrier3.5\n", __selftid));
barrier->barrier->inited = 0;
post_sem(barrier->barrier->sema, 0);
}
__DEBUG_PRINT(("tid %d barrier4\n", __selftid));
wait_sem(barrier->barrier->sema, 0);
__DEBUG_PRINT(("tid %d barrier5\n", __selftid));
post_sem(barrier->barrier->sema, 0);
__threadpool[__selftid].barrier = NULL;
__threadpool[__selftid].state = E_NORMAL;
leave_sync();
return 0;
}
return -1;
}
UINT32 imagelib_thread_main(IMAGELIB_MSG_PARA_LIST* msg)
{
IMAGELIB_MSG_PARA_LIST* para_list = (IMAGELIB_MSG_PARA_LIST*)msg;
IMAGELIB_SESSION* session = NULL;
if(para_list == NULL || para_list->session==NULL)
return 0;
session = para_list->session;
wait_sem(session->decode_sem);
if(para_list->msg_id == IMAGELIB_SAVEFRAMEDATA_MSG ||para_list->msg_id == IMAGELIB_DRAWFRAMEDATA_MSG )
{
session->error_code = imagelib_main_impl(session,para_list->src_instance,para_list->dest_instance,para_list->src_rect,
para_list->dest_width,para_list->dest_height,para_list->effect_para);
if (para_list->dest_instance != NULL)
{
image_close(para_list->dest_instance,TRUE);
}
if( session->state == IMAGELIB_DECODING)
{
session->state = IMAGELIB_IDLE;
imagelib_dispose_frame_ending(para_list->ending_cb,session,NULL,para_list->session->error_code);
}
}
else if(para_list->msg_id == IMAGELIB_GETFRAMEDATA_MSG)
{
DISP_BITMAP* bitmap=NULL;
session->error_code =imagelib_main_impl(session,para_list->src_instance,para_list->dest_instance,para_list->src_rect,
para_list->dest_width,para_list->dest_height,para_list->effect_para);
if (para_list->dest_instance != NULL)
{
if(session->error_code != IMAGELIB_SUCCESS)
{
image_close(para_list->dest_instance,TRUE);
bitmap = NULL;
}
else
{
bitmap =(DISP_BITMAP*)image_get_result(para_list->dest_instance);
image_close(para_list->dest_instance,FALSE);
}
}
if( session->state == IMAGELIB_DECODING)
{
para_list->session->state = IMAGELIB_IDLE;
imagelib_dispose_frame_ending(para_list->ending_cb,session,bitmap,para_list->session->error_code);
}
}
if(para_list->session->state == IMAGELIB_CLOSED)
{
if(session->pathname)
IMAGE_FREE(session->pathname);
image_close((IMAGE_INSTANCE*)session->instance_p,TRUE);
session->instance_p = NULL;
if(para_list->session->decode_sem != NULL)
{
signal_sem(para_list->session->decode_sem);
kill_sem(para_list->session->decode_sem);
para_list->session->decode_sem = NULL;
}
IMAGE_FREE(para_list->session);
}
else
signal_sem(session->decode_sem);
IMAGE_FREE(para_list);
return 0;
}
int main()
{
//Crear/Abrir semaforo
int semid = abrir_sem(SEMAFOROS, 3);
if(semid == -1)
{
printf("\nError al crear el semaforo\n");
return -1;
}
int msgQ = msgget(LLAVEMSG, IPC_CREAT | 0666);
if(msgQ == -1)
{
printf("\nError al abrir la cola de mensajes\n");
return -1;
}
tablero* tab;
respuesta resp;
resp.tipo = 2;
pregunta preg;
preg.tipo = 1;
int i, j;
int turno = 0;
int puntuacion = 0;
int x,y;
//Compartir el tablero
int tabMemID = shmget(PLAYER1, sizeof(tablero), IPC_CREAT | 0666);
if(tabMemID == -1)
{
printf("\nError al crear el tablero\n");
return -1;
}
tab = (tablero*) shmat(tabMemID, 0, 0);
for(i = 0;i < 3;i++)
for(j = 0; j < 3; j++)
tab->valores[i][j] = 0;
//Llenar tabla con 1, 2 y 3
i = 0;
while(i < 3)
{
printf("\nSelecciona la posición del %d: ",i+1);
scanf("%d,%d",&x, &y);
if((x > 2) || (y > 2))
{
printf("\nPosiciones invalidas (entre 0 y 2");
continue;
}
if(tab->valores[x][y] != 0)
{
printf("\nYa hay un numero ahi\n");
continue;
}
else
{
tab->valores[x][y] = i+1;
i++;
}
}
shmdt(tab);
// printf("Esperando que el Jugador 2 llene su tablero...");
// signal_sem(semid, SEM_P2);
// wait_sem(semid, SEM_P1);
printf("\nEsperando al monitor");
wait_sem(semid, SEM_P1);
while(turno < 3)
{
/*Modo Activo*/
printf("\n=================================");
printf("\n\nTurno %d\n\n", turno+1);
printf("Escribe la posicion a atacar (x,y): ");
scanf("%d,%d",&x,&y);
preg.x = x;
preg.y = y;
msgsnd(msgQ, &preg, sizeof(pregunta) - sizeof(long), IPC_NOWAIT);
// printf("\nEsperando respuesta\n");
msgrcv(msgQ, &resp, sizeof(respuesta) - sizeof(long), 2, 0);
// printf("\nRespuesta recibida");
printf("\nPuntos obtenidos: %d\n\n", resp.valor);
puntuacion += resp.valor;
turno++;
/*Modo Pasivo*/
printf("Espera tu turno...\n");
msgrcv(msgQ, &preg, sizeof(pregunta) - sizeof(long), 1, 0);
// printf("\nPregunta recibida");
tab = (tablero*) shmat(tabMemID, 0, 0);
int val = tab->valores[preg.x][preg.y];
tab->valores[preg.x][preg.y] = -1;
shmdt(tab);
// printf("\nSignal SEM_MON");
signal_sem(semid, SEM_MON);
// printf("\nWait SEM_P1");
wait_sem(semid, SEM_P1);
resp.valor = val;
// printf("\nEnviando respuesta");
msgsnd(msgQ, &resp, sizeof(respuesta) - sizeof(long), 0);
// printf("\nRespuesta enviada");
}
printf("\n\nJuego terminado, puntuacion total: %d\n", puntuacion);
return 0;
}
int main(int argc, char** argv)
{
Semaphore sem_dock;
Semaphore mutex_dock;
Semaphore sem_gen_v;
Shm shm_dock;
struct mq_attr attr1;
struct mq_attr attr2;
mqd_t mqd_trucks;
mqd_t mqd_cars_vans;
char mq1_name[MQ_NAME_LENGTH];
char mq2_name[MQ_NAME_LENGTH];
char* port_name = argv[1];
char* msg = malloc(sizeof(msg));
int dock_index;
int nb_docks;
int stop = 0;
int num_read = 0;
void *buffer;
sscanf(argv[2], "%d", &dock_index);
sscanf(argv[3], "%d", &nb_docks);
init_ressources(&sem_dock, &mutex_dock, &shm_dock, port_name, dock_index, nb_docks);
// Mise a zero des info de la Shm
Dock dock;
dock.index = dock_index;
dock.boat_index = -1;
wait_sem(mutex_dock);
memcpy(shm_dock.pShm + (dock_index * sizeof(Dock)), &dock, sizeof(Dock));
signal_sem(mutex_dock);
while (!stop)
{
// Attente d'un bateau
printf("\t\t Quai %s %d > En attente %s\n", port_name, dock_index, sem_dock.semname);
wait_sem(sem_dock);
wait_sem(mutex_dock);
memcpy(&dock, shm_dock.pShm + (dock_index * sizeof(Dock)), sizeof(Dock));
signal_sem(mutex_dock);
sprintf(msg, "Bateau %d a quai", dock.boat_index);
print_boat(port_name, dock_index, dock.boat_index, msg);
// Ouverture MQ --- TODO: refactor with open_mq, ...
sprintf(mq1_name, "%s%d", MQ_TRUCKS, dock.boat_index);
sprintf(mq2_name, "%s%d", MQ_CARS_VANS, dock.boat_index);
mqd_trucks = mq_open(mq1_name, O_RDONLY | O_NONBLOCK);
mqd_cars_vans = mq_open(mq2_name, O_RDONLY | O_NONBLOCK);
if (mqd_trucks == (mqd_t) -1 || mqd_cars_vans == (mqd_t) -1)
{
perror("Error when opening MQs (trucks, cars, vans)");
}
if (mq_getattr(mqd_trucks, &attr1) == -1 || mq_getattr(mqd_cars_vans, &attr2) == -1)
{
perror("Erreur when mq_getattr\n");
}
buffer = malloc(attr1.mq_msgsize);
// Début du débarquement
sprintf(msg, "Debut debarquement");
print_boat(port_name, dock_index, dock.boat_index, msg);
// Débarquement des camions
sprintf(msg, "Debarquement de %ld camions", attr1.mq_curmsgs);
print_boat(port_name, dock_index, dock.boat_index, msg);
if(attr1.mq_curmsgs > 0)
{
while(num_read != -1)
{
num_read = mq_receive(mqd_trucks, buffer, attr1.mq_msgsize, NULL);
nanosleep((struct timespec[]){{0, 250000000}}, NULL);
}
}
num_read = 0;
// Débarquement des voitures/vans
sprintf(msg, "Debarquement de %ld voitures/vans", attr2.mq_curmsgs);
print_boat(port_name, dock_index, dock.boat_index, msg);
if(attr2.mq_curmsgs > 0)
{
while(num_read != -1)
{
num_read = mq_receive(mqd_cars_vans, buffer, attr2.mq_msgsize, NULL);
nanosleep((struct timespec[]){{0, 250000000}}, NULL);
}
}
/*
-create a thread to create and connect a socket
-orphan the thread if does not return within timeout period
-return socket connection success/fail
-limit number of connection threads orphaned at any
given time so that if one is orphaned, return connection
fail
Algorithm assumption is that if orphaned thread(s) then network problems,
and probably due to not online. A more general solution would take into
account that different callers may/probably would have different dests
and any problems could be on the dest end
*/
RC_TYPE tcp_initialize_async(TCP_SOCKET *p_self,CB_EXIT_COND p_exit_func,void *p_cb_data)
{
#ifndef _WIN32
pthread_t c_thread=0;
#else
unsigned long c_thread=0;
#endif
CONNECT_THREAD_DATA *p_thread_data;
CONNECT_THREAD_DATA *p_thread_return=NULL;
int sleep_time=0;
RC_TYPE ret_rc;
TCP_SOCKET *p_this_self;
int is_exit_request=0;
int is_t_data_mutex_released=0;
int is_got_test_timer_mutex;
DBG_PRINTF((LOG_INFO,"I:" MODULE_TAG "Entered tcp_initialize_async...\n"));
if (!(p_self)) {
DBG_PRINTF((LOG_CRIT,"C:" MODULE_TAG "p_self null in tcp_initialize_async...\n"));
return RC_INVALID_POINTER;
}
get_mutex(&connect_in_progress_mutex);
if (!(is_connect_in_progress)) {
/*no orphaned thread, not in timer loop*/
get_mutex(&timer_loop_mutex);
}
else {
/*orphaned thread, or still in timer loop -- don't let still in loop prevent us an attempt*/
if ((get_mutex_try(&timer_loop_mutex)==0)) {
/*we've orphaned a connection thread because of timeout -- just return connection failure*/
DBG_PRINTF((LOG_INFO,"I:" MODULE_TAG "connection in progress in tcp_initialize_async...\n"));
release_mutex(&timer_loop_mutex);
release_mutex(&connect_in_progress_mutex);
return RC_IP_CONNECT_FAILED;
}
}
is_connect_in_progress+=1;
release_mutex(&connect_in_progress_mutex);
/*if client requests exit we may abandon connect thread
so rallocate client's p_self data -- we'll deallocate
this if connect thread exits normally -- so our
dangling thread does not have p_self data pulled out
from under it when/if our client quits*/
/*see the function to see just what is/isn't cloned*/
tcp_clone(&p_this_self,p_self);
p_self=p_this_self;
is_got_test_timer_mutex=(get_mutex_try(&test_timer_loop_mutex)==0);
p_thread_data=create_connect_data(p_self);
get_mutex(&p_thread_data->t_data_mutex);
create_connect_thread(&c_thread,p_thread_data);
/*loop/sleep 'til thread returns or prog exit requested*/
while(!(p_thread_data->is_thread_exit) && !((is_exit_request=p_exit_func(p_cb_data)))) {
sleep_time+=sleep_lightly_ms(1000,p_exit_func,p_cb_data);
if (!(sleep_time<p_self->super.timeout)) {
DBG_PRINTF((LOG_INFO,"I:" MODULE_TAG "tcp_initialize_async timed out...\n"));
break;
}
}
if (p_thread_data->is_thread_exit) {
release_mutex(&p_thread_data->t_data_mutex);
is_t_data_mutex_released=1;
}
else {
DBG_PRINTF((LOG_INFO,"I:" MODULE_TAG "connect thread has not exited...attempting to shutdown socket in tcp_initialize_async...\n"));
if ((kill_thread(c_thread)==0)) {
c_thread=0;
DBG_PRINTF((LOG_WARNING,"W:" MODULE_TAG "killed connect thread in tcp_initialize_async...\n"));
}
}
if (c_thread) {
DBG_PRINTF((LOG_INFO,"I:" MODULE_TAG "tcp_initialize_async joinng connect thread...\n"));
exit_thread(c_thread,(void **) &p_thread_return);
}
DBG_PRINTF((LOG_INFO,"I:" MODULE_TAG "tcp_initialize_async returning...\n"));
if (is_exit_request)
ret_rc=global_is_online;
else {
global_is_online=p_thread_data->rc;
ret_rc=global_is_online;
}
if (is_got_test_timer_mutex)
release_mutex(&test_timer_loop_mutex);
release_mutex(&timer_loop_mutex);
/*if program not quiting, and thread exited, free assocated data*/
if (!(p_thread_data->is_thread_exit)) {
p_thread_data->is_parent_exit=1;
release_mutex(&p_thread_data->t_data_mutex);
}
else {
if (!(is_t_data_mutex_released))
release_mutex(&p_thread_data->t_data_mutex);
wait_sem(&p_thread_data->t_data_sem);
DBG_PRINTF((LOG_INFO,"I:" MODULE_TAG "destroying connect data in tcp_initialize_async...\n"));
destroy_connect_data(&p_thread_data);
}
return ret_rc;
}
// argv[1] = port name
int main(int argc, char** argv)
{
Semaphore sem_gen_v;
Semaphore mutex_boat;
Semaphore mutex_sync;
Shm shm_boat;
Boat boat;
mqd_t mqd_trucks;
mqd_t mqd_cars_vans;
char buffer[MQ_MSGSIZE];
char* port_name = argv[1];
char* msg = malloc(sizeof(msg));
int i = 0;
int nb_trucks = 0, nb_cars = 0, nb_vans = 0;
int nb_boats = atoi(getProp(PROP_FILE, "nb_boats"));
srand(getpid());
// SEM_GEN_V
sem_gen_v.oflag = (O_CREAT | O_RDWR);
sem_gen_v.mode = 0644;
sem_gen_v.value = 0;
sprintf(sem_gen_v.semname,"%s%s", SEM_GEN_V, port_name);
sem_unlink(sem_gen_v.semname);
open_sem(&sem_gen_v);
// Preparing mutex for shm_boat access
mutex_boat.oflag = O_RDWR;
mutex_boat.mode = 0644;
mutex_boat.value = 1;
strcpy(mutex_boat.semname, MUTEX_BOAT);
open_sem(&mutex_boat);
// Preparing shm_boat access
shm_boat.sizeofShm = sizeof(Boat) * 6;
shm_boat.mode = O_RDWR;
strcpy(shm_boat.shmName, SHM_BOAT);
open_shm(&shm_boat);
mapping_shm(&shm_boat, sizeof(Boat) * 6);
while(1)
{
// Waiting signal_sem on sem_gen_v from Docks processes.
wait_sem(sem_gen_v);
// Waiting for access on shm_boat
wait_sem(mutex_boat);
boat = get_actual_boat(DOCK, port_name, nb_boats, shm_boat);
signal_sem(mutex_boat);
sprintf(msg, "Débloqué");
print_boat(port_name, boat.index, msg);
// MUTEX_SYNC
mutex_sync.oflag = 0;
sprintf(mutex_sync.semname,"%s%d", MUTEX_SYNC, boat.index);
open_sem(&mutex_sync);
// Ouverture MQs
mqd_trucks = mq_open(boat.mq1.name, O_WRONLY);
mqd_cars_vans = mq_open(boat.mq2.name, O_WRONLY);
nb_cars = rand() % MAX_N_CARS + 1;
nb_vans = rand() % MAX_N_VANS + 1;
nb_trucks = rand()% MAX_N_TRUCKS + 1;
memset(buffer, 0, MQ_MSGSIZE);
sprintf(msg, "Debut embarquement");
print_boat(port_name, boat.index, msg);
sprintf(msg, "Embarquement de %d voitures", nb_cars);
print_boat(port_name, boat.index, msg);
for(i = 0; i < nb_cars; i++)
{
sprintf(buffer, "Car %d", i + 1);
if(mq_send(mqd_cars_vans, buffer, strlen(buffer), CAR_PRIORITY) == -1)
{
mq_close(mqd_cars_vans);
mq_unlink(boat.mq1.name);
perror("Error occured when mq_send (cars & vans)\n");
exit(EXIT_FAILURE);
}
// Sleep 1/4s -- TODO Paramétrable.
nanosleep((struct timespec[]){{0, 250000000}}, NULL);
}
sprintf(msg, "Embarquement de %d vans", nb_vans);
print_boat(port_name, boat.index, msg);
for(i = 0; i < nb_vans; i++)
{
sprintf(buffer, "Van %d", i);
if(mq_send(mqd_cars_vans, buffer, strlen(buffer), VAN_PRIORITY) == -1)
{
mq_close(mqd_cars_vans);
mq_unlink(boat.mq1.name);
perror("Error occured when mq_send (cars & vans)\n");
exit(EXIT_FAILURE);
}
// Sleep 1/4s
nanosleep((struct timespec[]){{0, 250000000}}, NULL);
}
KERNEL_HANDLE
KernelCreateTask
(
KERNEL_TASK_START_ENTRY startEntry,
ULONG stackSize,
ULONG priority,
KERNEL_HANDLE hContext,
char* taskName
)
{
static ULONG taskNo = 0;
PKERNEL_TASK_CONTEXT pTaskContext = NULL;
PROCESS pProc;
wait_sem(&gSerializeSem);
KernelTrace2
(
KERNEL_DBG_LEVEL_TRACE_FLOW,
KERNEL_DBG_MASK_GENERIC,
"KernelCreateTask -- taskName = %s, startEntry = 0x%X, stackSize = %d, priority = %d, context = 0x%X.\n",
taskName,
startEntry,
stackSize,
priority,
hContext
);
pTaskContext = KernelAllocateMemory(sizeof(KERNEL_TASK_CONTEXT));
if (pTaskContext == NULL)
{
KernelTrace2
(
KERNEL_DBG_LEVEL_WARNING,
KERNEL_DBG_MASK_GENERIC,
"KernelCreateTask -- cannot allocate memory for the task context, size = %d.\n",
sizeof(KERNEL_TASK_CONTEXT)
);
signal_sem(&gSerializeSem);
return KERNEL_HANDLE_NULL;
}
pTaskContext->StartEntry = startEntry;
pTaskContext->hContext = hContext;
KernelAssert(gpTaskContext == NULL);
gpTaskContext = pTaskContext;
pProc =
create_process
(
priority - (priority % 64),
taskName,
KernelTaskRoutineEntry,
stackSize,
priority % 64,
0,
(PROCESS)0,
(struct OS_redir_entry *)0,
0x0000,
(OSUSER)0
);
if (!pProc)
{
KernelTrace2
(
KERNEL_DBG_LEVEL_WARNING,
KERNEL_DBG_MASK_GENERIC,
"KernelCreateTask -- failed to create the process %s!\n",
taskName
);
/*
* capture this exception
*/
KernelAssert(FALSE);
signal_sem(&gSerializeSem);
return KERNEL_HANDLE_NULL;
}
/*
* start the process
*/
start(pProc);
/*
* wait for the process complete access to the global task context
*/
wait_sem(&gCompletionSem);
KernelAssert(gpTaskContext == NULL);
signal_sem(&gSerializeSem);
return (KERNEL_HANDLE)pProc;
}
