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;
}
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;
}
// 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;
}
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);
}
}
static void connect_thread(void *p_data)
#endif
{
CONNECT_THREAD_DATA *p_ct_data=(CONNECT_THREAD_DATA *) p_data;
TCP_SOCKET *p_self;
if (!(p_ct_data)) {
DBG_PRINTF((LOG_CRIT,"C:" MODULE_TAG "p_ct_data null in connect_thread...\n"));
}
else {
p_self=p_ct_data->p_self;
if (!(p_self)) {
DBG_PRINTF((LOG_CRIT,"C:" MODULE_TAG "p_ct_data->p_self null in connect_thread...\n"));
p_ct_data->rc=RC_INVALID_POINTER;
}
else {
DBG_PRINTF((LOG_INFO,"I:" MODULE_TAG "attempting to create socket in connect_thread...\n"));
if (!(tcp_create_quick_socket(p_self)==RC_OK)) {
global_is_online=RC_IP_CONNECT_FAILED;
DBG_PRINTF((LOG_CRIT,"C:" MODULE_TAG "failed socket create in connect_thread...\n"));
}
else {
DBG_PRINTF((LOG_INFO,"I:" MODULE_TAG "calling do_connect from connect_thread\n"));
if (RC_OK==(p_ct_data->rc=do_connect(p_self))) {
p_self->initialized=TRUE;
}
global_is_online=p_ct_data->rc;
DBG_PRINTF((LOG_INFO,"I:" MODULE_TAG "connect thread returned from connect, connected: %d\n",(p_ct_data->rc==RC_OK)));
}
}
p_ct_data->is_thread_exit=1;
get_mutex(&p_ct_data->t_data_mutex);
signal_sem(&p_ct_data->t_data_sem);
release_mutex(&p_ct_data->t_data_mutex);
if (p_ct_data->is_parent_exit) {
/*we're orphaned, and in case program still running, deallocate what can*/
DBG_PRINTF((LOG_INFO,"I:" MODULE_TAG "connect thread destroying parent data...\n"));
destroy_connect_data(&p_ct_data);
}
DBG_PRINTF((LOG_INFO,"I:" MODULE_TAG "connect thread exiting...\n"));
}
get_mutex(&connect_in_progress_mutex);
is_connect_in_progress-=1;
release_mutex(&connect_in_progress_mutex);
#ifdef _WIN32
_endthread();
#else
pthread_exit(p_ct_data);
/*compiler complaints (pthread_exit does not return)*/
return p_ct_data;
#endif
}
// 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;
}
