static ssize_t max11802_read(FAR struct file *filep, FAR char *buffer, size_t len) { FAR struct inode *inode; FAR struct max11802_dev_s *priv; FAR struct touch_sample_s *report; struct max11802_sample_s sample; int ret; iinfo("buffer:%p len:%d\n", buffer, len); DEBUGASSERT(filep); inode = filep->f_inode; DEBUGASSERT(inode && inode->i_private); priv = (FAR struct max11802_dev_s *)inode->i_private; /* Verify that the caller has provided a buffer large enough to receive * the touch data. */ if (len < SIZEOF_TOUCH_SAMPLE_S(1)) { /* We could provide logic to break up a touch report into segments and * handle smaller reads... but why? */ ierr("ERROR: Unsupported read size: %d\n", len); return -ENOSYS; } /* Get exclusive access to the driver data structure */ ret = sem_wait(&priv->devsem); if (ret < 0) { /* This should only happen if the wait was cancelled by an signal */ ierr("ERROR: sem_wait: %d\n", errno); DEBUGASSERT(errno == EINTR); return -EINTR; } /* Try to read sample data. */ ret = max11802_sample(priv, &sample); if (ret < 0) { /* Sample data is not available now. We would ave to wait to get * receive sample data. If the user has specified the O_NONBLOCK * option, then just return an error. */ iinfo("Sample data is not available\n"); if (filep->f_oflags & O_NONBLOCK) { ret = -EAGAIN; goto errout; } /* Wait for sample data */ ret = max11802_waitsample(priv, &sample); if (ret < 0) { /* We might have been awakened by a signal */ ierr("ERROR: max11802_waitsample: %d\n", ret); goto errout; } } /* In any event, we now have sampled MAX11802 data that we can report * to the caller. */ report = (FAR struct touch_sample_s *)buffer; memset(report, 0, SIZEOF_TOUCH_SAMPLE_S(1)); report->npoints = 1; report->point[0].id = sample.id; report->point[0].x = sample.x; report->point[0].y = sample.y; /* Report the appropriate flags */ if (sample.contact == CONTACT_UP) { /* Pen is now up. Is the positional data valid? This is important to * know because the release will be sent to the window based on its * last positional data. */ if (sample.valid) { report->point[0].flags = TOUCH_UP | TOUCH_ID_VALID | TOUCH_POS_VALID; } else { report->point[0].flags = TOUCH_UP | TOUCH_ID_VALID; } } else if (sample.contact == CONTACT_DOWN) { /* First contact */ report->point[0].flags = TOUCH_DOWN | TOUCH_ID_VALID | TOUCH_POS_VALID; } else /* if (sample->contact == CONTACT_MOVE) */ { /* Movement of the same contact */ report->point[0].flags = TOUCH_MOVE | TOUCH_ID_VALID | TOUCH_POS_VALID; } iinfo(" id: %d\n", report->point[0].id); iinfo(" flags: %02x\n", report->point[0].flags); iinfo(" x: %d\n", report->point[0].x); iinfo(" y: %d\n", report->point[0].y); ret = SIZEOF_TOUCH_SAMPLE_S(1); errout: sem_post(&priv->devsem); iinfo("Returning: %d\n", ret); return ret; }
ssize_t nxffs_write(FAR struct file *filep, FAR const char *buffer, size_t buflen) { FAR struct nxffs_volume_s *volume; FAR struct nxffs_wrfile_s *wrfile; ssize_t remaining; ssize_t nwritten; ssize_t total; int ret; fvdbg("Write %d bytes to offset %d\n", buflen, filep->f_pos); /* Sanity checks */ DEBUGASSERT(filep->f_priv != NULL && filep->f_inode != NULL); /* Recover the open file state from the struct file instance */ wrfile = (FAR struct nxffs_wrfile_s *)filep->f_priv; /* Recover the volume state from the open file */ volume = (FAR struct nxffs_volume_s *)filep->f_inode->i_private; DEBUGASSERT(volume != NULL); /* Get exclusive access to the volume. Note that the volume exclsem * protects the open file list. */ ret = sem_wait(&volume->exclsem); if (ret != OK) { ret = -get_errno(); fdbg("ERROR: sem_wait failed: %d\n", ret); goto errout; } /* Check if the file was opened with write access */ if ((wrfile->ofile.oflags & O_WROK) == 0) { fdbg("ERROR: File not open for write access\n"); ret = -EACCES; goto errout_with_semaphore; } /* Loop until we successfully appended all of the data to the file (or an * error occurs) */ for (total = 0; total < buflen; ) { remaining = buflen - total; /* Have we already allocated the data block? */ if (wrfile->doffset == 0) { /* No, allocate the data block now, re-packing if necessary. */ wrfile->datlen = 0; ret = nxffs_wralloc(volume, wrfile, remaining); if (ret < 0) { fdbg("ERROR: Failed to allocate a data block: %d\n", -ret); goto errout_with_semaphore; } } /* Seek to the FLASH block containing the data block */ nxffs_ioseek(volume, wrfile->doffset); /* Verify that the FLASH data that was previously written is still intact */ ret = nxffs_reverify(volume, wrfile); if (ret < 0) { fdbg("ERROR: Failed to verify FLASH data block: %d\n", -ret); goto errout_with_semaphore; } /* Append the data to the end of the data block and write the updated * block to flash. */ nwritten = nxffs_wrappend(volume, wrfile, &buffer[total], remaining); if (nwritten < 0) { fdbg("ERROR: Failed to append to FLASH to a data block: %d\n", -ret); goto errout_with_semaphore; } /* Decrement the number of bytes remaining to be written */ total += nwritten; } /* Success.. return the number of bytes written */ ret = total; filep->f_pos = wrfile->datlen; errout_with_semaphore: sem_post(&volume->exclsem); errout: return ret; }
/* This is a simulation of the process diagram on slide 38 module 06-Concurrency */ void * p( void * arg ) { unsigned k , mynum ; mynum = ( unsigned ) arg ; pthread_detach( pthread_self() ); switch( mynum ) { case 1: printf("Thread %d started\n", mynum); SPIN ; printf("Thread %d ended\n", mynum); sem_post( & s[1] /* or simply s+1 */ ); sem_post( s+1 ); sem_post( s+1 ); break ; case 2: sem_wait( s+1 ) ; printf("Thread %d started\n", mynum); SPIN ; printf("Thread %d ended\n", mynum); sem_post( s+2 ); sem_post( s+2 ); break ; case 3: sem_wait( s+2 ) ; printf("Thread %d started\n", mynum); SPIN ; printf("Thread %d ended\n", mynum); sem_post( s+3 ); break ; case 4: sem_wait( s+2 ) ; printf("Thread %d started\n", mynum); SPIN ; printf("Thread %d ended\n", mynum); sem_post( s+4 ); break ; case 5: sem_wait( s+1 ) ; printf("Thread %d started\n", mynum); SPIN ; printf("Thread %d ended\n", mynum); sem_post( s+5 ); break ; case 6: sem_wait( s+4 ) ; sem_wait( s+5 ) ; printf("Thread %d started\n", mynum); SPIN ; printf("Thread %d ended\n", mynum); sem_post( s+6 ); break ; case 7: sem_wait( s+1 ) ; printf("Thread %d started\n", mynum); SPIN ; printf("Thread %d ended\n", mynum); sem_post( s+7 ); break ; case 8: sem_wait( s+3 ) ; sem_wait( s+6 ) ; sem_wait( s+7 ) ; printf("Thread %d started\n", mynum); SPIN ; printf("Thread %d ended\n", mynum); sem_post( s+8 ); break ; }; pthread_exit( NULL ) ; }
DttSP_EXP void Audio_Callback2 (float **input, float **output, unsigned int nframes) { unsigned int thread; BOOLEAN b = reset_em; BOOLEAN return_empty=FALSE; unsigned int i; for(thread=0;thread<threadno;thread++) { if (top[thread].susp) return_empty = TRUE; } if (return_empty) { for(thread=0;thread<threadno;thread++) { memset (output[2*thread], 0, nframes * sizeof (float)); memset (output[2*thread+1], 0, nframes * sizeof (float)); } return; } if (b) { //fprintf(stderr, "reset_em!\n"); fflush(stderr); //fprintf(stdout,"Audio_Callback2: reset_em = TRUE\n"), fflush(stdout); reset_system_audio(nframes); for(thread=0;thread<threadno;thread++) { memset (output[2*thread], 0, nframes * sizeof (float)); memset (output[2*thread+1], 0, nframes * sizeof (float)); } return; } #if 0 if (diversity.flag) { // Deal with the transmitter first if ((ringb_float_read_space (top[1].jack.ring.o.l) >= nframes) && (ringb_float_read_space (top[1].jack.ring.o.r) >= nframes)) { ringb_float_read (top[1].jack.ring.o.l, output[2], nframes); ringb_float_read (top[1].jack.ring.o.r, output[3], nframes); } else { // rb pathology //reset_system_audio(nframes); for(thread=0;thread<threadno;thread++) { memset (output[thread], 0, nframes * sizeof (float)); memset (output[thread], 0, nframes * sizeof (float)); } return; } // input: copy from port to ring if ((ringb_float_write_space (top[1].jack.ring.i.l) >= nframes) && (ringb_float_write_space (top[1].jack.ring.i.r) >= nframes)) { ringb_float_write (top[1].jack.ring.i.l, input[2], nframes); ringb_float_write (top[1].jack.ring.i.r, input[3], nframes); } else { // rb pathology for(thread=0;thread<threadno;thread++) { memset (output[thread], 0, nframes * sizeof (float)); memset (output[thread], 0, nframes * sizeof (float)); } return; } // if enough accumulated in ring, fire dsp if ((ringb_float_read_space (top[1].jack.ring.i.l) >= top[1].hold.size.frames) && (ringb_float_read_space (top[1].jack.ring.i.r) >= top[1].hold.size.frames)) sem_post (&top[1].sync.buf.sem); // // Deal with the diversity channel next // if ((ringb_float_read_space (top[0].jack.ring.o.l) >= nframes) && (ringb_float_read_space (top[0].jack.ring.o.r) >= nframes)) { /*ringb_float_read (top[thread].jack.auxr.o.l, output[l], nframes); ringb_float_read (top[thread].jack.auxr.o.r, output[r], nframes);*/ ringb_float_read (top[0].jack.ring.o.l, output[2], nframes); ringb_float_read (top[0].jack.ring.o.r, output[3], nframes); } else { // rb pathology //reset_system_audio(nframes); for(thread=0;thread<threadno;thread++) { memset (output[thread], 0, nframes * sizeof (float)); memset (output[thread], 0, nframes * sizeof (float)); } return; } // Deal with the diversity/phased array channel next // input: copy from port to ring if ((ringb_float_write_space (top[0].jack.ring.i.l) >= nframes) && (ringb_float_write_space (top[0].jack.ring.i.r) >= nframes) && (ringb_float_write_space (top[2].jack.ring.i.l) >= nframes) && (ringb_float_write_space (top[2].jack.ring.i.r) >= nframes)) { REAL *l0 = input[0]; REAL *r0 = input[1]; REAL *l2 = input[4]; REAL *r2 = input[5]; for (i=0;i<nframes;i++) { COMPLEX A = Cmplx(l0[i],r0[i]); COMPLEX B = Cmplx(l2[i],r2[i]); A = Cscl(Cadd(A,Cmul(B,diversity.scalar)),diversity.gain); ringb_float_write (top[0].jack.ring.i.l, &A.re, 1); ringb_float_write (top[0].jack.ring.i.r, &A.im, 1); } /*ringb_float_write (top[thread].jack.auxr.i.l, input[l], nframes); ringb_float_write (top[thread].jack.auxr.i.r, input[r], nframes);*/ } else { // rb pathology //reset_system_audio(nframes); for(thread=0;thread<threadno;thread++) { memset (output[thread], 0, nframes * sizeof (float)); memset (output[thread], 0, nframes * sizeof (float)); } return; } // if enough accumulated in ring, fire dsp if ((ringb_float_read_space (top[0].jack.ring.i.l) >= top[0].hold.size.frames) && (ringb_float_read_space (top[0].jack.ring.i.r) >= top[0].hold.size.frames)) sem_post (&top[0].sync.buf.sem); // // Deal with 2nd receiver channel now // if ((ringb_float_read_space (top[2].jack.ring.o.l) >= nframes) && (ringb_float_read_space (top[2].jack.ring.o.r) >= nframes)) { /*ringb_float_read (top[thread].jack.auxr.o.l, output[l], nframes); ringb_float_read (top[thread].jack.auxr.o.r, output[r], nframes);*/ ringb_float_read (top[2].jack.ring.o.l, output[4], nframes); ringb_float_read (top[2].jack.ring.o.r, output[5], nframes); } else { // rb pathology //reset_system_audio(nframes); for(thread=0;thread<threadno;thread++) { memset (output[thread], 0, nframes * sizeof (float)); memset (output[thread], 0, nframes * sizeof (float)); } return; } // input: copy from port to ring if ((ringb_float_write_space (top[2].jack.ring.i.l) >= nframes) && (ringb_float_write_space (top[2].jack.ring.i.r) >= nframes)) { ringb_float_write (top[2].jack.ring.i.l, input[4], nframes); ringb_float_write (top[2].jack.ring.i.r, input[5], nframes); } else { // rb pathology for(thread=0;thread<threadno;thread++) { memset (output[thread], 0, nframes * sizeof (float)); memset (output[thread], 0, nframes * sizeof (float)); } return; } // if enough accumulated in ring, fire dsp if ((ringb_float_read_space (top[2].jack.ring.i.l) >= top[2].hold.size.frames) && (ringb_float_read_space (top[2].jack.ring.i.r) >= top[2].hold.size.frames)) sem_post (&top[2].sync.buf.sem); } else #endif for(thread=0; thread<threadno; thread++) { int l=2*thread, r = 2*thread+1; if ((ringb_float_read_space (top[thread].jack.ring.o.l) >= nframes) && (ringb_float_read_space (top[thread].jack.ring.o.r) >= nframes)) { /*ringb_float_read (top[thread].jack.auxr.o.l, output[l], nframes); ringb_float_read (top[thread].jack.auxr.o.r, output[r], nframes);*/ ringb_float_read (top[thread].jack.ring.o.l, output[l], nframes); ringb_float_read (top[thread].jack.ring.o.r, output[r], nframes); } else { // rb pathology //reset_system_audio(nframes); for(thread=0;thread<threadno;thread++) { memset (output[2*thread ], 0, nframes * sizeof (float)); memset (output[2*thread+1], 0, nframes * sizeof (float)); } return; } // input: copy from port to ring if ((ringb_float_write_space (top[thread].jack.ring.i.l) >= nframes) && (ringb_float_write_space (top[thread].jack.ring.i.r) >= nframes)) { if (diversity.flag && (thread == 0)) { if ((ringb_float_write_space (top[2].jack.ring.i.l) >= nframes) && (ringb_float_write_space (top[2].jack.ring.i.r) >= nframes)) { REAL *l0 = input[0]; REAL *r0 = input[1]; REAL *l2 = input[4]; REAL *r2 = input[5]; for (i=0;i<nframes;i++) { COMPLEX A = Cmplx(l0[i],r0[i]); COMPLEX B = Cmplx(l2[i],r2[i]); A = Cscl(Cadd(A,Cmul(B,diversity.scalar)),diversity.gain); ringb_float_write (top[0].jack.ring.i.l, &A.re, 1); ringb_float_write (top[0].jack.ring.i.r, &A.im, 1); } /*ringb_float_write (top[thread].jack.auxr.i.l, input[l], nframes); ringb_float_write (top[thread].jack.auxr.i.r, input[r], nframes);*/ } else { // rb pathology //reset_system_audio(nframes); for(thread=0;thread<threadno;thread++) { memset (output[2*thread ], 0, nframes * sizeof (float)); memset (output[2*thread+1], 0, nframes * sizeof (float)); } return; } } else { ringb_float_write (top[thread].jack.ring.i.l, input[l], nframes); ringb_float_write (top[thread].jack.ring.i.r, input[r], nframes); /*ringb_float_write (top[thread].jack.auxr.i.l, input[l], nframes); ringb_float_write (top[thread].jack.auxr.i.r, input[r], nframes);*/ } } else { // rb pathology //reset_system_audio(nframes); for(thread=0;thread<threadno;thread++) { memset (output[2*thread ], 0, nframes * sizeof (float)); memset (output[2*thread+1], 0, nframes * sizeof (float)); } return; } // if enough accumulated in ring, fire dsp if ((ringb_float_read_space (top[thread].jack.ring.i.l) >= top[thread].hold.size.frames) && (ringb_float_read_space (top[thread].jack.ring.i.r) >= top[thread].hold.size.frames)) sem_post (&top[thread].sync.buf.sem); } }
int main(int argc, char *argv[]) { int n_elements = 61; int n_processors = 10; // First calculate how much work to give to each process. // Really, this is just a dummy example. Each child will just // do some meaningless calculations as an example. int n_per_processor = n_elements / n_processors; int n_remaining = n_elements % n_processors; int node_start = 0; int node_end; printf("\n"); // Here we read the key for the shared memory. This will be availble // to all clients so they can attach to shared memory. // Remember, each child will inherit an exact copy of the stack and // heap. // // int shm_fd = shm_open("/wikastarea1", O_RDWR, 0755); if (shm_fd < 0) { perror("shm_open"); exit(0); } void *mptr = mmap(NULL, getpagesize(), PROT_READ|PROT_WRITE, MAP_SHARED, shm_fd, 0x0); if (mptr == MAP_FAILED) { perror("mmap"); exit(0); } shdata_t *shdata = (shdata_t *) mptr; sem_t *sem1 = sem_open("/wikassem1", 0); if (sem1 == SEM_FAILED) { perror("sem_open sem1"); exit(0); } sem_t *sem2 = sem_open("/wikassem2", 0); if (sem2 == SEM_FAILED) { perror("sem_open sem2"); exit(0); } int count = 0; for (int i=0; i < 100; i++) { sem_wait(sem2); printf("Damn! the pot is empty!\n"); for (int j=0; j < 10; j++) { shdata->values[j] = 1.0; printf("producing %d\n", ++count); } sem_post(sem1); } }
static gsize get_mpeg2ts_segment (RequestData *request_data, EncoderOutput *encoder_output, gchar **buf) { GstClockTime timestamp; gint number; guint64 year, month, mday, hour, sequence, duration, rap_addr, max_age; GstClockTime us; /* microseconds */ struct tm tm; gchar date[20], *header, *path, *file, *cache_control; gsize buf_size; GError *err = NULL; struct timespec ts; number = sscanf (request_data->uri, "/%*[^/]/encoder/%*[^/]/%04lu%02lu%02lu%02lu/%lu_%lu_%lu.ts$", &year, &month, &mday, &hour, &us, &sequence, &duration); if (number != 7) { GST_WARNING ("uri not found: %s", request_data->uri); *buf = g_strdup_printf (http_404, PACKAGE_NAME, PACKAGE_VERSION); buf_size = strlen (*buf); return buf_size; } sprintf (date, "%04lu-%02lu-%02lu %02lu:00:00", year, month, mday, hour); memset (&tm, 0, sizeof (struct tm)); strptime (date, "%Y-%m-%d %H:%M:%S", &tm); tm.tm_isdst = daylight; timestamp = mktime (&tm) * 1000000 + us; /* read from memory */ if (clock_gettime (CLOCK_REALTIME, &ts) == -1) { GST_ERROR ("get_mpeg2ts_segment clock_gettime error: %s", g_strerror (errno)); *buf = g_strdup_printf (http_500, PACKAGE_NAME, PACKAGE_VERSION); buf_size = strlen (*buf); return buf_size; } ts.tv_sec += 2; while (sem_timedwait (encoder_output->semaphore, &ts) == -1) { if (errno == EINTR) { continue; } GST_ERROR ("get_mpeg2ts_segment sem_timedwait failure: %s", g_strerror (errno)); *buf = g_strdup_printf (http_500, PACKAGE_NAME, PACKAGE_VERSION); buf_size = strlen (*buf); return buf_size; } /* seek gop */ rap_addr = encoder_output_gop_seek (encoder_output, timestamp); if (rap_addr != G_MAXUINT64) { /* segment found, send it */ gsize gop_size; gop_size = encoder_output_gop_size (encoder_output, rap_addr); cache_control = g_strdup_printf ("max-age=%lu", encoder_output->dvr_duration); header = g_strdup_printf (http_200, PACKAGE_NAME, PACKAGE_VERSION, "video/mpeg", gop_size, cache_control, ""); g_free (cache_control); *buf = g_malloc (strlen (header) + gop_size); memcpy (*buf, header, strlen(header)); if (rap_addr + gop_size + 12 < encoder_output->cache_size) { memcpy (*buf + strlen (header), encoder_output->cache_addr + rap_addr + 12, gop_size); } else { gint n; n = encoder_output->cache_size - rap_addr - 12; if (n > 0) { memcpy (*buf + strlen (header), encoder_output->cache_addr + rap_addr + 12, n); memcpy (*buf + strlen (header) + n, encoder_output->cache_addr, gop_size - n); } else { GST_WARNING ("nnnnn: n < 0 %d", n); memcpy (*buf + strlen (header), encoder_output->cache_addr - n, gop_size); } } buf_size = strlen (header) + gop_size; g_free (header); } else { buf_size = 0; } sem_post (encoder_output->semaphore); /* buf_size == 0? segment not found in memory, read frome dvr directory */ if (buf_size == 0) { path = g_strdup_printf ("%s/%04lu%02lu%02lu%02lu/%010lu_%lu_%lu.ts", encoder_output->record_path, year, month, mday, hour, us, sequence, duration); if (!g_file_get_contents (path, &file, &buf_size, &err)) { g_error_free (err); GST_WARNING ("segment not found: %s", request_data->uri); *buf = g_strdup_printf (http_404, PACKAGE_NAME, PACKAGE_VERSION); buf_size = strlen (*buf); } else { max_age = encoder_output->dvr_duration - (g_get_real_time () - timestamp) / 1000000; cache_control = g_strdup_printf ("max-age=%lu", max_age); header = g_strdup_printf (http_200, PACKAGE_NAME, PACKAGE_VERSION, "video/mpeg", buf_size, cache_control, ""); g_free (cache_control); *buf = g_malloc (buf_size + strlen (header)); memcpy (*buf, header, strlen (header)); memcpy (*buf + strlen (header), file, buf_size); buf_size += strlen (header); g_free (header); g_free (file); } g_free (path); } return buf_size; }
// Serves as a global method to trigger reinitialization // and as a function that can be provided to signal(). void reinit_signal_handler(int /*signal*/) { sem_post(&reinit); }
int service_engine(char *addr, int port) { int i; if(MAX_TASK_NUM > 0) { for (i = 0; i < MAX_TASK_NUM; i++) { sem_init(&event[i], 0, 0); int temp = i; if (pthread_create(&thread_id[i], NULL, (void *)handle_requests, (void *)temp) != 0) { printf("pthread_create error, %s:%d\n",__FILE__, __LINE__); exit(-1); } } } /* * command line console */ init_mdb(); ServiceHandler h = -1; initialize_service(addr,port); while(1) { h = service_start(); // handle_request(h); task_node_t *tnode = (task_node_t *)malloc( sizeof(task_node_t)); tnode->buf_size = MAX_BUF_LEN; if (receive_data (h, tnode->buf, &(tnode->buf_size)) == 0) { service_stop(h); continue; } if (MAX_TASK_NUM > 0) { tnode->req = h; int i = random_int(MAX_TASK_NUM); /* put tnode into task_list */ if (task_list[i] == NULL) { task_list[i] = tnode; tnode->next = NULL; tnode->last = tnode; } else { task_node_t *p = task_list[i]; p->last->next = tnode; p->last = tnode; tnode->next = NULL; } sem_post(&event[i]); // service_stop(h); } else { handle_one_request(h, tnode->buf, tnode->buf_size); free(tnode); } } shutdown_service(); close_mdb(); if (MAX_TASK_NUM > 0 ) { for (i = 0; i< MAX_TASK_NUM; i++) { task_node_t *p = task_list[i]; task_node_t *q; while (p) { q = p->next; free(p); p = q; } } } return 0; }
void threadfunc() { printf("Hello from threadfunc!\n"); sleep(3); sem_post(&g_sema); }
virtual void readDone(uint32_t v) { fprintf(stderr, "readDone %d\n", v); sem_post(&read_sem); }
/* * La cola RR solo la agregamos por compatibilidad, * siempre va a ser un puntero a NULL. */ uint32_t atender_peticion_orquestador(uint32_t cliente, t_stream *pedido, t_queue_rr *cola_rr){ /*t_stream *pedido; recibir(cliente, (void*)&pedido); */ t_header header; deserializar_header(pedido, &header); int32_t pos_payload = sizeof(t_header); //char personajeElegido; switch (header.type){ case HANDSHAKE_NUEVO_NIVEL:{ uint32_t nro_nivel; uint32_t puerto; t_stream *payload = get_payload(pedido); memcpy(&nro_nivel,&payload[0],4); memcpy(&puerto,&payload[4],4); t_planificador *nodo_planificador; nodo_planificador = get_nodo_nivel(nro_nivel); //log_debug(logger_orq, "Hand_nuevo_nivel: dir nodo_planificador = %d", nodo_planificador); if(nodo_planificador == NULL){ nodo_planificador = malloc(sizeof(t_planificador)); nodo_planificador->tid=malloc(sizeof(pthread_t)); nodo_planificador->nivel.direccion = malloc(sizeof(struct sockaddr_in)); log_info(logger_orq, "Handshake_nuevo_nivel: Nueva conexión, nivel %d.", nro_nivel); completar_datos_nivel(nro_nivel, cliente, nodo_planificador); nodo_planificador->planificador.descriptor = 0; (nodo_planificador->nivel.direccion)->sin_port=htons(puerto); list_mutex_add(planificadores, (void*) nodo_planificador); sem_post(&semaforo_nodos_nuevos); free(pedido); return EXIT_SUCCESS; } log_info(logger_orq, "Se reconecta en nivel %d.", nro_nivel); completar_datos_nivel(nro_nivel, cliente, nodo_planificador); (nodo_planificador->nivel.direccion)->sin_port=htons(puerto); free(pedido); return EXIT_SUCCESS; } case HANDSHAKE_NUEVO_PJ:{ int8_t simbolo_pj; t_stream *payload =get_payload(pedido); simbolo_pj = (int8_t)payload[0]; log_info(logger_orq, "Handshake_nuevo_pj: Nueva conexión, pj %c", simbolo_pj); t_personaje_finalizado *pj; int pos_pj; pos_pj = get_pos_pj_finalizado(simbolo_pj); //Si todavía no está en la lista lo metemos. if(pos_pj == -1){ log_debug(logger_orq, "Handshake_nuevo_pj: El pj no existía así que lo guardo en listo personajes_finalizados."); pj = malloc(sizeof(t_personaje_finalizado)); pj->simbolo_pj = simbolo_pj; pj->termino_plan_de_niveles = false; log_debug(logger_orq, "Handshake_nuevo_pj: Guardo: Simbolo = %c bool_fin = %d", pj->simbolo_pj, pj->termino_plan_de_niveles); list_mutex_add(personajes_finalizados, (void*)pj); t_personaje_finalizado *test_pj = list_mutex_get(personajes_finalizados, 0); log_debug(logger_orq,"Handshake_nuevo_pj: Guardé simbolo = %c, bool_fin = %d ", test_pj->simbolo_pj, test_pj->termino_plan_de_niveles); } else{ pthread_mutex_lock(&personajes_finalizados->mutex); pj = list_get(personajes_finalizados->list, pos_pj); pj->termino_plan_de_niveles = false; pthread_mutex_unlock(&personajes_finalizados->mutex); } t_stream *stream_senial_ok; stream_senial_ok = serializar_senial(OK); log_debug(logger_orq, "Handshake_nuevo_pj: Envío OK al pj recién conectado"); enviar(cliente, stream_senial_ok); free(stream_senial_ok); free(pedido); return EXIT_SUCCESS; } case SOLICITUD_DATOS_NIVEL:{ t_stream *payload = get_payload(pedido); int8_t simbolo_pj = payload[0]; int8_t nro_nivel = payload[1]; t_datos_nivel datos_nivel; datos_nivel.direccion_nivel[0] = '\0'; datos_nivel.direccion_planificador[0]='\0'; int resultado = get_datos_nivel(nro_nivel, &datos_nivel); //Si el nivel no existe o si todavía no se lanzó su planificador asociado. if(resultado == EXIT_FAILURE){ char cadena_vacia = 'a'; t_stream *stream_nivel_no_existe = serializar_solicitud(NO_EXISTE_EL_NIVEL, sizeof(cadena_vacia), (t_stream*)&cadena_vacia); log_info(logger_orq, "Sol_datos_nivel: El pj %c solicitó los datos del nivel %d pero el nivel aún no fue cargado.", simbolo_pj, nro_nivel); enviar(cliente, (void*) stream_nivel_no_existe); free(pedido); free(stream_nivel_no_existe); return EXIT_SUCCESS; } t_stream *stream_datos_nivel; //En esta linea tira stream_datos_nivel = serializar_datos_nivel(&datos_nivel); log_debug(logger_orq,"Sol_datos_nivel: Datos del nivel solicitado: %s",datos_nivel.direccion_nivel); log_debug(logger_orq, "Sol_datos_nivel: Datos del planificador solicitado: %s",datos_nivel.direccion_planificador); log_info(logger_orq, "Sol_datos_nivel: El pj %c solicitó los datos del nivel %d. Se responde con los datos solicitados.", simbolo_pj, nro_nivel); enviar(cliente, stream_datos_nivel); free(stream_datos_nivel); free(pedido); return EXIT_SUCCESS; } case RECURSOS_LIBERADOS:{ //Los recursos vienen en un string con formato HHHHFFFFMMMM, char *recursos = (char*) &pedido[pos_payload]; uint32_t nro_nivel = get_nro_nivel(cliente); log_debug(logger_orq,"Recursos_liberados: Obteniendo socket_pair del planificador."); int32_t socket_pair_planificador = get_socket_pair_planificador(nro_nivel); log_debug(logger_orq,"Recursos_liberados: El socket pair es: %d", socket_pair_planificador); int32_t indice_recurso = 0; int8_t personaje_recurso[2]; int8_t personaje_nro_nivel[2]; log_info(logger_orq, "Recursos_liberados: El nivel %d liberó los recursos: %s ", nro_nivel, recursos); while(recursos[indice_recurso] != '\0'){ //La función pasa a un pj de bloqueados a personajes_listos. int8_t simbolo_pj_desbloqueado = desbloquear_personaje(recursos[indice_recurso], nro_nivel); if (simbolo_pj_desbloqueado>0) log_info(logger_orq,"Recursos_liberados: PJ elegido para desbloquear: %c, recurso: %c", simbolo_pj_desbloqueado, recursos[indice_recurso]); else log_info(logger_orq,"Recursos_liberados: Ningún pj esperaba el recurso %c", recursos[indice_recurso]); //Si no hay un pj que necesite ese recurso, en lugar del símbolo del pj envía -1. personaje_recurso[0] = simbolo_pj_desbloqueado; personaje_recurso[1] = recursos[indice_recurso]; t_stream *stream_pj_recurso = serializar_solicitud(DESBLOQUEAR_PERSONAJE, 2*sizeof(int8_t), (t_stream*) personaje_recurso); //Aviso al planificador para que lo saque de personajes_listo y lo ponga en cola_rr if(simbolo_pj_desbloqueado != -1){ personaje_nro_nivel[0] = simbolo_pj_desbloqueado; personaje_nro_nivel[1] = (int8_t) nro_nivel; log_debug(logger_orq,"Recursos_liberados: Envio al planificador pj: %c, nro_nivel: %d", personaje_nro_nivel[0], personaje_nro_nivel[1]); t_stream *stream_pj_nro_nivel = serializar_solicitud(DESBLOQUEAR_PERSONAJE, 2*sizeof(int8_t), (t_stream*) personaje_nro_nivel); int test_result_sock_pair = enviar(socket_pair_planificador, (void*) stream_pj_nro_nivel); if(test_result_sock_pair == EXIT_FAILURE) log_error(logger_orq,"Recursos_liberados: Error al enviar mensaje al socket_pair (nro %d)del planificador ", socket_pair_planificador); else log_debug(logger_orq,"Recursos_liberados: Se envió el msj al socket_pair nro %d", socket_pair_planificador); free(stream_pj_nro_nivel); } log_debug(logger_orq,"Recursos_liberados: Envio al nivel pj: %c, recurso: %c ", personaje_recurso[0], personaje_recurso[1]); enviar(cliente, (void*)stream_pj_recurso); free(stream_pj_recurso); //simbolo_pj_desbloqueado = desbloquear_personaje(recursos[indice_recurso], nro_nivel); indice_recurso++; } free(pedido); return EXIT_SUCCESS; } case FIN_PLAN_NIVELES:{ t_stream *payload = get_payload(pedido); int8_t simbolo_pj = payload[0]; log_info(logger_orq,"Fin_plan_niveles: El pj %c terminó su plan de niveles ", simbolo_pj); int pos_pj = get_pos_pj_finalizado(simbolo_pj); log_debug(logger_orq,"Fin_plan_niveles: Pos del pj finalizado = %d", pos_pj); t_personaje_finalizado *pj_finalizado = list_mutex_get(personajes_finalizados, pos_pj); pj_finalizado->termino_plan_de_niveles = true; if(todos_los_pj_terminaron()){ log_info(logger_orq,"Fin_plan_niveles: Todos los pj finalizaron su plan de niveles."); solicitar_fin_ejecucion_planificadores(); //Variable global que está en el while principal de todos los hilos. keep_running = false; estado_plataforma = false; sem_post(&semaforo_nodos_nuevos); } log_debug(logger_orq, "Fin_plan_niveles: FIN_PLAN_DE_NIVELES,case: retorno EXIT_SUCCESS;"); free(pedido); return EXIT_SUCCESS; } case RECOVERY:{ log_info(logger_orq, "Llegó pedido de recovery."); int8_t * personajesEnDeadlock = (int8_t*) &pedido[pos_payload]; printf("Llegó string: %s \n", personajesEnDeadlock); log_info(logger_orq, "Los PJs involucrados en el interbloqueo son %s", personajesEnDeadlock); t_personaje_listo *personajeElegido; int index_pj = 0; //Este while es solo por contención, se supone el pj[0] siempre va a estar bloqueado. while(personajesEnDeadlock[index_pj] != '\0'){ int8_t simbolo_pj = personajesEnDeadlock[index_pj]; personajeElegido= list_remove_personaje(personajes_bloqueados, simbolo_pj); if(personajeElegido != NULL){ log_info(logger_orq, "Recovery: Se da muerte al pj %c y se notifica al nivel.", personajeElegido->simbolo_pj); notificarPersonajeAsesinado(cliente, personajeElegido); if(index_pj != 0) log_info(logger_orq, "El pj asesinado estaba en la posición %d", index_pj); free(pedido); return EXIT_SUCCESS; } index_pj++; } log_error(logger_orq, "No se encontró ningún personaje para asesinar."); free(pedido); return EXIT_SUCCESS; } case HUBO_UNA_DESCONEXION:{ log_info(logger_orq, "Hubo una desconexión."); free(pedido); return EXIT_SUCCESS; } log_warning(logger_orq, "Hubo_desconexión: Recibo petición de tipo desconocida"); return EXIT_SUCCESS; } /* case RECOVERY:{//todo: agregar al serializador //todo: matar_personaje, func q devuelve el nombre de pj asesinado. //char *nombre_personaje = matar_personaje(); notificacion_pj_asesinado(cliente, nombre_personaje); free(nombre_personaje); free(pedido); //todo: poner free pedido fuera de atender_peticion()? return EXIT_SUCCESS; }*/ return EXIT_SUCCESS; }
virtual void writeDone(uint32_t v) { fprintf(stderr, "writeDone %d\n", v); sem_post(&write_sem); }
static inline void cgi_semgive(void) { sem_post(&g_cgisem); }
virtual void bscanGet(uint64_t v) { printf("bscanGet: %llx\n", (long long)v); sem_post(&sem_bscan); }
static int process_callback( jack_nframes_t nframes, void *arg ) { int c; jack_handle_t* handle = (jack_handle_t*)arg; size_t to_read = nframes; for(c=0; c<handle->channels; ++c) handle->ports_buf[c] = jack_port_get_buffer(handle->ports[c], nframes); /* One ringbuffer to rule them all, getting interleaved data piecewise and appending to non-interleaved buffers. */ while(to_read) { /* Need to read into temporary storage, then deinterleave to JACK buffers. */ size_t got_piece; size_t avail_piece; size_t piece = to_read > handle->procbuf_frames ? handle->procbuf_frames : to_read; /* Ensure we get only full PCM frames by checking available byte count and reducing expectation. */ avail_piece = jack_ringbuffer_read_space(handle->rb)/handle->framesize; got_piece = jack_ringbuffer_read( handle->rb , handle->procbuf, (avail_piece > piece ? piece : avail_piece) * handle->framesize ) / handle->framesize; debug2( "fetched %"SIZE_P" frames from ringbuffer (wanted %"SIZE_P")" , (size_p)got_piece, (size_p)piece ); /* If this is the last piece, fill up, not time to wait. */ if(to_read > piece) piece = got_piece; /* We got further loop cycle(s) to get the rest. */ else { if(piece > got_piece) { debug("filling up with zeros"); bzero( handle->procbuf+got_piece*handle->framesize , (piece-got_piece)*handle->framesize ); } } /* Now extract the pieces for the channels. */ for (c=0; c < handle->channels; ++c) { size_t n; jack_default_audio_sample_t *dst = handle->ports_buf[c]; if(handle->encoding == MPG123_ENC_FLOAT_32) { float* src = (float*)handle->procbuf; for(n=0; n<piece; ++n) *(dst++) = src[(n*handle->channels)+c]; } else /* MPG123_ENC_FLOAT_64 */ { double* src = (double*)handle->procbuf; for(n=0; n<piece; ++n) *(dst++) = src[(n*handle->channels)+c]; } /* Store output buffer offset. */ handle->ports_buf[c] = dst; } /* Give the writer a hint about the time passed. */ sem_post(&handle->sem); to_read -= piece; } /* Success*/ return 0; }
void threadfunc1() { printf("Hello from threadfunc1\n"); sleep(5); sem_post(&g_sema); }
static GstClockTime send_chunk (EncoderOutput *encoder_output, RequestData *request_data) { HTTPStreamingPrivateData *priv_data; gint64 current_gop_end_addr, tail_addr; gint32 ret; struct timespec ts; priv_data = request_data->priv_data; if (clock_gettime (CLOCK_REALTIME, &ts) == -1) { GST_ERROR ("send_chunk clock_gettime error: %s", g_strerror (errno)); return 100 * GST_MSECOND + g_random_int_range (1, 1000000); } ts.tv_sec += 2; while (sem_timedwait (encoder_output->semaphore, &ts) == -1) { if (errno == EINTR) { continue; } GST_ERROR ("send_chunk sem_timedwait failure: %s", g_strerror (errno)); return 100 * GST_MSECOND + g_random_int_range (1, 1000000); } tail_addr = *(encoder_output->tail_addr); current_gop_end_addr = get_current_gop_end (encoder_output, priv_data); if (priv_data->send_count == priv_data->chunk_size + priv_data->chunk_size_str_len + 2) { /* completly send a chunk, prepare next. */ priv_data->send_position += priv_data->send_count - priv_data->chunk_size_str_len - 2; if (priv_data->send_position == encoder_output->cache_size) { priv_data->send_position = 0; } g_free (priv_data->chunk_size_str); priv_data->chunk_size_str_len = 0; priv_data->chunk_size = 0; } if (priv_data->send_position == current_gop_end_addr) { /* next gop. */ priv_data->rap_addr = current_gop_end_addr; if (priv_data->send_position + 12 < encoder_output->cache_size) { priv_data->send_position += 12; } else { priv_data->send_position = priv_data->send_position + 12 - encoder_output->cache_size; } current_gop_end_addr = get_current_gop_end (encoder_output, priv_data); } sem_post (encoder_output->semaphore); if (priv_data->chunk_size == 0) { if (current_gop_end_addr == -1) { /* current output gop. */ if ((tail_addr - priv_data->send_position) > 16384) { priv_data->chunk_size = 16384; } else if (tail_addr > priv_data->send_position) { /* send to tail. */ priv_data->chunk_size = tail_addr - priv_data->send_position; } else if (tail_addr == priv_data->send_position) { /* no data available, wait a while. */ return 100 * GST_MSECOND + g_random_int_range (1, 1000000); } else if ((encoder_output->cache_size - priv_data->send_position) > 16384) { priv_data->chunk_size = 16384; } else { priv_data->chunk_size = encoder_output->cache_size - priv_data->send_position; } } else { /* completely output gop. */ if ((current_gop_end_addr - priv_data->send_position) > 16384) { priv_data->chunk_size = 16384; } else if (current_gop_end_addr > priv_data->send_position) { /* send to gop end. */ priv_data->chunk_size = current_gop_end_addr - priv_data->send_position; } else if (current_gop_end_addr == priv_data->send_position) { /* no data available, wait a while. */ return 100 * GST_MSECOND + g_random_int_range (1, 1000000); //FIXME FIXME } else { /* send to cache end. */ priv_data->chunk_size = encoder_output->cache_size - priv_data->send_position; } } priv_data->chunk_size_str = g_strdup_printf ("%x\r\n", priv_data->chunk_size); priv_data->chunk_size_str_len = strlen (priv_data->chunk_size_str); priv_data->send_count = 0; } /* send data. */ ret = send_data (encoder_output, request_data); if (ret == -1) { return GST_CLOCK_TIME_NONE; } else { priv_data->send_count += ret; request_data->bytes_send += ret; } if (priv_data->send_count == priv_data->chunk_size + priv_data->chunk_size_str_len + 2) { /* send complete, wait 10 ms. */ return 10 * GST_MSECOND + g_random_int_range (1, 1000000); } else { /* not send complete, blocking, wait 200 ms. */ return 200 * GST_MSECOND + g_random_int_range (1, 1000000); } }
int main(void) { int ret, status; pid_t child, ctl; pthread_t th; output_init(); ctl = getpid(); /* Initialize the semaphore */ sem = sem_open("/fork_21_1", O_CREAT, O_RDWR, 0); if (sem == SEM_FAILED) UNRESOLVED(errno, "Failed to open the semaphore"); sem_unlink("/fork_21_1"); /* Create thread */ ret = pthread_create(&th, NULL, threaded, &ctl); if (ret != 0) UNRESOLVED(ret, "Failed to create the thread"); /* Create the child */ child = fork(); if (child == -1) UNRESOLVED(errno, "Failed to fork"); /* We post the semaphore twice */ do { ret = sem_post(sem); } while (ret != 0 && errno == EINTR); if (ret != 0) UNRESOLVED(errno, "Failed to post the semaphore"); /* child */ if (child == 0) { /* sleep a little while to let the thread execute in case it exists */ sleep(1); /* We're done */ exit(PTS_PASS); } /* Parent joins the child */ ctl = waitpid(child, &status, 0); if (ctl != child) UNRESOLVED(errno, "Waitpid returned the wrong PID"); if (!WIFEXITED(status) || WEXITSTATUS(status) != PTS_PASS) FAILED("Child exited abnormally"); /* Destroy everything */ ret = sem_close(sem); if (ret != 0) UNRESOLVED(errno, "Failed to close the semaphore"); ret = pthread_join(th, NULL); if (ret != 0) UNRESOLVED(ret, "Failed to join the thread in parent"); #if VERBOSE > 0 output("Test passed\n"); #endif PASSED; }
void stdout_stats_and_post_sem_cb(struct rb_mse_api *rb_mse, struct rb_mse_stats *stats, void *_sem) { sem_t * sem = _sem; stdout_stats_cb(rb_mse,stats,NULL); sem_post(sem); }
static int stream_transfer(struct stream_transfer *stream_transfer) { struct dev_stream *stream_sender; struct dev_stream *stream_receiver; int size_transfer = 0; int ret =0; int exit_flag =0; int i =0; short* Srcptr; short* Drcptr; stream_sender = stream_transfer->stream_sender; stream_receiver = stream_transfer->stream_receiver; size_transfer = stream_sender->buf_size; #ifdef START_ZERO_BUFFER /* 消除开头杂音 */ memset(stream_sender->buf, 0, stream_sender->buf_size); pcm_write(stream_receiver->dev, stream_sender->buf, stream_sender->buf_size); #endif while( 1 ){ if ( (!stream_transfer->voice_thread_run_flag) || (exit_flag == 1)){ break; } ret = pcm_read(stream_sender->dev, stream_sender->buf, size_transfer); if (ret != 0) { exit_flag = 1; ALOGE("err: read codec err:%s, ret=%d", strerror(errno), ret); break; } if ( (!stream_transfer->voice_thread_run_flag) || (exit_flag == 1)){ break; } ret = pcm_write(stream_receiver->dev, stream_sender->buf, size_transfer); if (ret != 0) { exit_flag = 1; ALOGE("err: write pcm err:%s, ret=%d", strerror(errno), ret); } if ( (!stream_transfer->voice_thread_run_flag) || (exit_flag == 1)){ break; } if (stream_transfer->record_flag == 1){ //是上行,还是下行. if (stream_transfer->voice_direction == UPSTREAM){ Srcptr = (short*)(stream_sender->buf); Drcptr = (short*)(record_data.record_buf + (record_data.lenwriteup%record_data.record_lenth)); if(record_data.lenwriteup >= record_data.lenwritedown) { memcpy(Drcptr,Srcptr,size_transfer); } else { int i; for(i=0;i<size_transfer/2;i++,Drcptr++) { *Drcptr = (*Drcptr + *Srcptr++)/2; } record_data.lenwrite += size_transfer; // sem_post(&sem_record); } record_data.lenwriteup += size_transfer; //ALOGD("stream is upload"); } else { Srcptr = (short*)(stream_sender->buf); Drcptr = (short*)(record_data.record_buf + (record_data.lenwritedown%record_data.record_lenth)); if(record_data.lenwritedown >= record_data.lenwriteup) { memcpy(Drcptr,Srcptr,size_transfer); } else { for(i=0;i<size_transfer/2;i++,Drcptr++) { *Drcptr = ((int)*Drcptr + (int)(*Srcptr++))/2; } record_data.lenwrite += size_transfer; // sem_post(&sem_record); } record_data.lenwritedown += size_transfer; //ALOGD("stream is download"); } sem_post(&sem_record); } //ALOGD("pcm running ... , type=%d ",stream_sender->type); if ( (!stream_transfer->voice_thread_run_flag) || (exit_flag == 1)){ break; } } return 0; }
DttSP_EXP void Audio_Callback (float *input_l, float *input_r, float *output_l, float *output_r, unsigned int nframes, int thread) { BOOLEAN b = reset_em; int i; i=thread; if (top[i].susp) { memset (output_l, 0, nframes * sizeof (float)); memset (output_r, 0, nframes * sizeof (float)); return; } if (b) { //fprintf(stdout,"Audio_Callback: call reset_system_audio\n"), fflush(stdout); reset_system_audio(nframes); memset (output_l, 0, nframes * sizeof (float)); memset (output_r, 0, nframes * sizeof (float)); return; } //for (i=0; i<2; i++) //{ if ((ringb_float_read_space (top[i].jack.ring.o.l) >= nframes) && (ringb_float_read_space (top[i].jack.ring.o.r) >= nframes)) { if (top[i].state == RUN_PLAY) { ringb_float_read (top[i].jack.auxr.o.l, output_l, nframes); ringb_float_read (top[i].jack.auxr.o.r, output_r, nframes); ringb_float_read (top[i].jack.ring.o.l, output_l, nframes); ringb_float_read (top[i].jack.ring.o.r, output_r, nframes); } else { ringb_float_read_advance (top[i].jack.auxr.o.l, nframes); ringb_float_read_advance (top[i].jack.auxr.o.r, nframes); ringb_float_read_advance (top[i].jack.ring.o.l, nframes); ringb_float_read_advance (top[i].jack.ring.o.r, nframes); } } else { // rb pathology //fprintf(stdout,"Audio_Callback-2: rb out pathology\n"), fflush(stdout); // reset_system_audio(nframes); // memset (output_l, 0, nframes * sizeof (float)); // memset (output_r, 0, nframes * sizeof (float)); } // input: copy from port to ring if ((ringb_float_write_space (top[i].jack.ring.i.l) >= nframes) && (ringb_float_write_space (top[i].jack.ring.i.r) >= nframes)) { ringb_float_write (top[i].jack.ring.i.l, (float *) input_l, nframes); ringb_float_write (top[i].jack.ring.i.r, (float *) input_r, nframes); ringb_float_write (top[i].jack.auxr.i.l, (float *) input_l, nframes); ringb_float_write (top[i].jack.auxr.i.r, (float *) input_r, nframes); } else { // rb pathology //fprintf(stdout,"Audio_Callback-3: rb in pathology\n"), fflush(stdout); // reset_system_audio(nframes); // memset (output_l, 0, nframes * sizeof (float)); // memset (output_r, 0, nframes * sizeof (float)); } // if enough accumulated in ring, fire dsp if (ringb_float_read_space (top[i].jack.ring.i.l) >= top[i].hold.size.frames) sem_post (&top[i].sync.buf.sem); //} }
virtual void reportMemoryTraffic(uint64_t words){ //fprintf(stderr, "reportMemoryTraffic: words=%"PRIx64"\n", words); mtCnt = words; sem_post(&mtSem); }
static uint16_t netclose_interrupt(FAR struct net_driver_s *dev, FAR void *pvconn, FAR void *pvpriv, uint16_t flags) { #ifdef CONFIG_NET_SOLINGER FAR struct tcp_close_s *pstate = (FAR struct tcp_close_s *)pvpriv; #endif FAR struct tcp_conn_s *conn = (FAR struct tcp_conn_s *)pvconn; DEBUGASSERT(conn != NULL); nllvdbg("conn: %p flags: %04x\n", conn, flags); /* TCP_DISCONN_EVENTS: * TCP_CLOSE: The remote host has closed the connection * TCP_ABORT: The remote host has aborted the connection * TCP_TIMEDOUT: The remote did not respond, the connection timed out * NETDEV_DOWN: The network device went down */ if ((flags & TCP_DISCONN_EVENTS) != 0) { /* The disconnection is complete */ #ifdef CONFIG_NET_SOLINGER /* pstate non-NULL means that we are performing a LINGERing close. */ if (pstate) { /* Wake up the waiting thread with a successful result */ pstate->cl_result = OK; goto end_wait; } /* Otherwise, nothing is waiting on the close event and we can perform * the completion actions here. */ else #endif { /* Free connection resources */ tcp_free(conn); /* Stop further callbacks */ flags = 0; } } #ifdef CONFIG_NET_SOLINGER /* Check for a timeout. */ else if (pstate && close_timeout(pstate)) { /* Yes.. Wake up the waiting thread and report the timeout */ nlldbg("CLOSE timeout\n"); pstate->cl_result = -ETIMEDOUT; goto end_wait; } #endif /* CONFIG_NET_SOLINGER */ #ifdef CONFIG_NET_TCP_WRITE_BUFFERS /* Check if all outstanding bytes have been ACKed */ else if (conn->unacked != 0 || !sq_empty(&conn->write_q)) { /* No... we are still waiting for ACKs. Drop any received data, but * do not yet report TCP_CLOSE in the response. */ dev->d_len = 0; flags = (flags & ~TCP_NEWDATA); } #endif /* CONFIG_NET_TCP_WRITE_BUFFERS */ else { /* Drop data received in this state and make sure that TCP_CLOSE * is set in the response */ dev->d_len = 0; flags = (flags & ~TCP_NEWDATA) | TCP_CLOSE; } return flags; #ifdef CONFIG_NET_SOLINGER end_wait: pstate->cl_cb->flags = 0; pstate->cl_cb->priv = NULL; pstate->cl_cb->event = NULL; sem_post(&pstate->cl_sem); nllvdbg("Resuming\n"); return 0; #endif }
void *eng_vlog_thread(void *x) { int ser_fd, modem_fd; int r_cnt, w_cnt, offset; int retry_num = 0; int dumpmemlen = 0; eng_dev_info_t* dev_info = (eng_dev_info_t*)x; ENG_LOG("eng_vlog thread start\n"); /*open usb/uart*/ ENG_LOG("eng_vlog open serial...\n"); ser_fd = eng_open_dev(dev_info->host_int.dev_log, O_WRONLY); if(ser_fd < 0) { ENG_LOG("eng_vlog open serial failed, error: %s\n", strerror(errno)); return NULL; } /*open vbpipe/spipe*/ ENG_LOG("eng_vlog open SIPC channel...\n"); do{ modem_fd = open(dev_info->modem_int.log_chan, O_RDONLY); if(modem_fd < 0) { ENG_LOG("eng_vlog cannot open %s, error: %s\n", dev_info->modem_int.log_chan, strerror(errno)); sleep(5); } if((++retry_num) > MAX_OPEN_TIMES) { ENG_LOG("eng_vlog SIPC open times exceed the max times, vlog thread stopped.\n"); goto out; } }while(modem_fd < 0); ENG_LOG("eng_vlog put log data from SIPC to serial\n"); while(1) { int split_flag = 0; if(g_armlog_enable) { sem_post(&g_armlog_sem); } sem_wait(&g_armlog_sem); memset(log_data, 0, sizeof(log_data)); r_cnt = read(modem_fd, log_data, DATA_BUF_SIZE); if (r_cnt <= 0) { ENG_LOG("eng_vlog read no log data : r_cnt=%d, %s\n", r_cnt, strerror(errno)); continue; } // printf dump memory len dump_mem_len_print(r_cnt, &dumpmemlen); offset = 0; //reset the offset if((r_cnt%64==0) && dev_info->host_int.cali_flag && (dev_info->host_int.dev_type == CONNECT_USB)) split_flag = 1; do { if(split_flag) w_cnt = write(ser_fd, log_data + offset, r_cnt-32); else w_cnt = write(ser_fd, log_data + offset, r_cnt); if (w_cnt < 0) { if(errno == EBUSY) usleep(59000); else { ENG_LOG("eng_vlog no log data write:%d ,%s\n", w_cnt, strerror(errno)); // FIX ME: retry to open retry_num = 0; //reset the try number. while (-1 == restart_gser(&ser_fd, dev_info->host_int.dev_log)) { ENG_LOG("eng_vlog open gser port failed\n"); sleep(1); retry_num ++; if(retry_num > MAX_OPEN_TIMES) { ENG_LOG("eng_vlog: vlog thread stop for gser error !\n"); sem_post(&g_armlog_sem); return 0; } } } } else { r_cnt -= w_cnt; offset += w_cnt; split_flag = 0; //ENG_LOG("eng_vlog: r_cnt: %d, w_cnt: %d, offset: %d\n", r_cnt, w_cnt, offset); } } while(r_cnt > 0); } out: ENG_LOG("eng_vlog thread end\n"); if (modem_fd >= 0) close(modem_fd); close(ser_fd); return 0; }
void TasksQueue::incrementTasksToProcess() { sem_post(&tasksToBeProcessed); }
int CDCWinProc (HWND hWnd, int message, WPARAM wParam, LPARAM lParam) { switch (message) { case MSG_CREATE: UI_Set_From_Handl( hWnd); UI_LoadRes(); break; case MSG_PAINT: if(is_init_all==T) { U_SBtn_Flag=1; UI_InitFrom(hWnd); UI_Set_Device_State(0,0); sem_post(&Device_semt); SendLaneInfo("等待上班"); is_init_all = F; if (GetUseAutoMan()==T) { SetTimer(hWnd, 10, 10); } else { SetTimer(hWnd, 100, 100); } } break; case MSG_TIMER: if(GetMoneyTimer()<=3) { CloseMoneyBox(); } if (Getg_bWeiZhang()) { Setg_bWeiZhangCount(Getg_bWeiZhangCount()+1); if (Getg_bWeiZhangCount()>=atoi(sys_ini.RushCancelTime)) { Setg_Violation(1); AddMsgTotal_Violation(); SendMessageWzCar(0); SetWorkSationEndWz(); SetVideoAlarm(F); Setg_bWeiZhangCount(0); Setg_bWeiZhang(F); } } if ( GetCanTestPrinter( )) { TestPrintState(); } // WF_TestICReader(); updateTime( ); CheckHourSend(); SendTCOMsg(MSGTCO_NETWORK,"OK"); AutoManHandl(); break; case MSG_KEYDOWN: if (KeyDown) { WorkStation(KeyTran(wParam)); echoic("wParam = <%d><%d>",wParam,KeyTran(wParam)); KeyDown = F; } break; case MSG_KEYUP: KeyDown = T; break; case MSG_BAR_UP: echoic("MSG_BAR_UPMSG_BAR_UPMSG_BAR_UPMSG_BAR_UPMSG_BAR_UP"); G_CurrentSystemDevStatus.TongGuoLine = 1; PassLineUP(); break; case MSG_BAR_DOWN: G_CurrentSystemDevStatus.TongGuoLine = 0; PassLineDown(); break; case MSG_PIC_UP: G_CurrentSystemDevStatus.ZhuaPaiLine = 1; InLineUP(); break; case MSG_PIC_DOWN: G_CurrentSystemDevStatus.ZhuaPaiLine = 0; InLineDown(); break; case MSG_REMOTECONTROL: WorkStation(KeyTran(wParam)); break; case MSG_CLOSE: DestroyMainWindow (hWnd); PostQuitMessage (hWnd); return 0; case MSG_CRADENENT: if (GetEnableIC()) { SetCardNO(lParam);//必须先赋予卡号 switch (wParam) { case CSC_CARDENTER :// 1201 //卡进入读卡器可读范围 SetCardExist(T); break; case CSC_CARDEXIT: SetCardExist(F); break; } SetCardInReader(T); WorkStation(wParam); SetCardInReader(F); } break; } return DefaultMainWinProc (hWnd, message, wParam, lParam); }
/* * ======== RcmServerThreadFxn ======== * RCM server test thread function */ Void RcmServerThreadFxn (Void *arg) { RcmServer_Params rcmServerParams; UInt fxnIdx; Char * rcmServerName = RCMSERVER_NAME; Int status = 0; /* Rcm server module init */ Osal_printf ("RcmServerThreadFxn: RCM Server module init.\n"); RcmServer_init (); /* Rcm server module params init*/ Osal_printf ("RcmServerThreadFxn: RCM Server module params init.\n"); status = RcmServer_Params_init (&rcmServerParams); if (status < 0) { Osal_printf ("RcmServerThreadFxn: Error in RCM Server instance params " "init \n"); goto exit; } Osal_printf ("RcmServerThreadFxn: RCM Server instance params init " "passed \n"); /* Create the RcmServer instance */ Osal_printf ("RcmServerThreadFxn: Creating RcmServer instance %s.\n", rcmServerName); status = RcmServer_create (rcmServerName, &rcmServerParams, &rcmServerHandle); if (status < 0) { Osal_printf ("RcmServerThreadFxn: Error in RCM Server create.\n"); goto exit; } Osal_printf ("RcmServerThreadFxn: RCM Server Create passed \n"); sem_init (&serverThreadSync, 0, 0); /* Register the remote functions */ Osal_printf ("RcmServerThreadFxn: Registering remote function - " "fxnDouble\n"); status = RcmServer_addSymbol (rcmServerHandle, "fxnDouble", fxnDouble, &fxnIdx); if ((status < 0) || (fxnIdx == 0xFFFFFFFF)) { Osal_printf ("RcmServerThreadFxn: Add symbol failed.\n"); goto exit; } Osal_printf ("RcmServerThreadFxn: Registering remote function - " "fxnExit\n"); status = RcmServer_addSymbol (rcmServerHandle, "fxnExit", fxnExit, &fxnIdx); if ((status < 0) || (fxnIdx == 0xFFFFFFFF)) { Osal_printf ("RcmServerThreadFxn: Add symbol failed.\n"); goto exit; } Osal_printf ("RcmServerThreadFxn: Start RCM server thread \n"); RcmServer_start (rcmServerHandle); Osal_printf ("RcmServerThreadFxn: RCM Server start passed \n"); sem_wait (&serverThreadSync); sem_post (&mainThreadWait); exit: Osal_printf ("RcmServerThreadFxn: Leaving RCM server test thread " "function \n"); return; }
void uwsgi_unlock_fast(struct uwsgi_lock_item *uli) { sem_post((sem_t *) uli->lock_ptr); uli->pid = 0; }
bool Sem::Post() { return sem_post(&m_sem) == 0; }
static void max11802_worker(FAR void *arg) { FAR struct max11802_dev_s *priv = (FAR struct max11802_dev_s *)arg; FAR struct max11802_config_s *config; uint16_t x; uint16_t y; uint16_t xdiff; uint16_t ydiff; bool pendown; int ret; int tags, tags2; ASSERT(priv != NULL); /* Get a pointer the callbacks for convenience (and so the code is not so * ugly). */ config = priv->config; DEBUGASSERT(config != NULL); /* Disable the watchdog timer. This is safe because it is started only * by this function and this function is serialized on the worker thread. */ wd_cancel(priv->wdog); /* Lock the SPI bus so that we have exclusive access */ max11802_lock(priv->spi); /* Start coordinate measurement */ (void)max11802_sendcmd(priv, MAX11802_CMD_MEASUREXY, &tags); /* Get exclusive access to the driver data structure */ do { ret = sem_wait(&priv->devsem); /* This should only fail if the wait was cancelled by an signal * (and the worker thread will receive a lot of signals). */ DEBUGASSERT(ret == OK || errno == EINTR); } while (ret < 0); /* Check for pen up or down by reading the PENIRQ GPIO. */ pendown = config->pendown(config); /* Handle the change from pen down to pen up */ if (pendown) { iinfo("\nPD\n"); } else { iinfo("\nPU\n"); } if (!pendown) { /* The pen is up.. reset thresholding variables. */ priv->threshx = INVALID_THRESHOLD; priv->threshy = INVALID_THRESHOLD; /* Ignore the interrupt if the pen was already up (CONTACT_NONE == * pen up and already reported; CONTACT_UP == pen up, but not * reported). */ iinfo("\nPC%d\n", priv->sample.contact); if (priv->sample.contact == CONTACT_NONE || priv->sample.contact == CONTACT_UP) { goto ignored; } /* The pen is up. NOTE: We know from a previous test, that this is a * loss of contact condition. This will be changed to CONTACT_NONE * after the loss of contact is sampled. */ priv->sample.contact = CONTACT_UP; } /* It is a pen down event. If the last loss-of-contact event has not been * processed yet, then we have to ignore the pen down event (or else it * will look like a drag event) */ else if (priv->sample.contact == CONTACT_UP) { /* If we have not yet processed the last pen up event, then we * cannot handle this pen down event. We will have to discard it. * That should be okay because we will set the timer to to sample * again later. */ iinfo("Previous pen up event still in buffer\n"); max11802_notify(priv); wd_start(priv->wdog, MAX11802_WDOG_DELAY, max11802_wdog, 1, (uint32_t)priv); goto ignored; } else { /* Wait for data ready * * Note: MAX11802 signals the readiness of the results using * the lowest 4 bits of the result. However these are the * last bits to be read out of the device. It appears that * the hardware value can change in the middle of the readout, * causing the upper bits to be still invalid even though lower * bits indicate valid result. * * We work around this by reading the registers once more after * the tags indicate they are ready. */ int readycount = 0; do { #ifdef CONFIG_MAX11802_SWAPXY x = max11802_sendcmd(priv, MAX11802_CMD_YPOSITION, &tags); y = max11802_sendcmd(priv, MAX11802_CMD_XPOSITION, &tags2); #else x = max11802_sendcmd(priv, MAX11802_CMD_XPOSITION, &tags); y = max11802_sendcmd(priv, MAX11802_CMD_YPOSITION, &tags2); #endif if (tags != 0xF && tags2 != 0xF) { readycount++; } } while (readycount < 2); /* Continue to sample the position while the pen is down */ wd_start(priv->wdog, MAX11802_WDOG_DELAY, max11802_wdog, 1, (uint32_t)priv); /* Check if data is valid */ if ((tags & 0x03) != 0) { iinfo("Touch ended before measurement\n"); goto ignored; } /* Perform a thresholding operation so that the results will be more * stable. If the difference from the last sample is small, then * ignore the event. * * REVISIT: Should a large change in pressure also generate a event? */ xdiff = x > priv->threshx ? (x - priv->threshx) : (priv->threshx - x); ydiff = y > priv->threshy ? (y - priv->threshy) : (priv->threshy - y); /* Check the thresholds. Bail if there is no significant difference */ if (xdiff < CONFIG_MAX11802_THRESHX && ydiff < CONFIG_MAX11802_THRESHY) { /* Little or no change in either direction ... don't report anything. */ goto ignored; } /* When we see a big difference, snap to the new x/y thresholds */ priv->threshx = x; priv->threshy = y; /* Update the x/y position in the sample data */ priv->sample.x = priv->threshx; priv->sample.y = priv->threshy; /* The X/Y positional data is now valid */ priv->sample.valid = true; /* If this is the first (acknowledged) pen down report, then report * this as the first contact. If contact == CONTACT_DOWN, it will be * set to set to CONTACT_MOVE after the contact is first sampled. */ if (priv->sample.contact != CONTACT_MOVE) { /* First contact */ priv->sample.contact = CONTACT_DOWN; } } /* Indicate the availability of new sample data for this ID */ priv->sample.id = priv->id; priv->penchange = true; /* Notify any waiters that new MAX11802 data is available */ max11802_notify(priv); ignored: config->enable(config, true); /* Release our lock on the state structure and unlock the SPI bus */ sem_post(&priv->devsem); max11802_unlock(priv->spi); }