/*! \brief The thread which pops stuff off the RTV queue and processes them \param data is the pointer to the queue to pop entries off of \returns NULL */ G_MODULE_EXPORT void *rtv_subscriber(gpointer data) { GAsyncQueue *queue = (GAsyncQueue *)data; static GMutex *mutex = NULL; LibreEMS_Packet *packet = NULL; ENTER(); mutex = (GMutex *)DATA_GET(global_data,"rtv_subscriber_mutex"); if (!mutex) g_thread_exit(0); while (!DATA_GET(global_data,"rtv_subscriber_thread_exit")) { /* Wait up to 0.25 seconds for thread to exit */ packet = (LibreEMS_Packet *)g_async_queue_timeout_pop(queue,250000); g_mutex_unlock(mutex); if (packet) { DATA_SET(global_data,"rt_goodread_count",GINT_TO_POINTER((GINT)DATA_GET(global_data,"rt_goodread_count")+1)); process_rt_vars_f(packet->data+packet->payload_base_offset,packet->payload_length); libreems_packet_cleanup(packet); } } g_thread_exit(0); EXIT(); return NULL; }
/*! \brief This function is a thread that sits and listens on the packet_queue for incoming data that has come from handle_data() after passing basic validation. This thread will call the dispatcher with the packet, which will fire off all appropriate subscribers to this packet \param data is unused \returns NULL */ void *packet_handler(gpointer data) { GTimeVal tval; FreeEMS_Packet *packet = NULL; GAsyncQueue *queue = (GAsyncQueue *)DATA_GET(global_data,"packet_queue"); GCond *cond = NULL; while(TRUE) { if ((DATA_GET(global_data,"leaving") || (DATA_GET(global_data,"packet_handler_thread_exit")))) { cond = (GCond *)DATA_GET(global_data,"packet_handler_cond"); if (cond) g_cond_signal(cond); g_thread_exit(0); } g_get_current_time(&tval); g_time_val_add(&tval,250000); packet = (FreeEMS_Packet *)g_async_queue_timed_pop(queue,&tval); if (packet) dispatch_packet_queues(packet); } g_thread_exit(0); return NULL; }
/*! \brief Windows reader thread. Runs continuously once port is open to a working device. This is a strict timeout blocking read due to windows's absolutelybraindead I/O model where select/poll isn't allowed on anything but network sockets. Overallpaed I/O is just too ugly... \param data is the encapsulation of the port filedescriptor \returns NULL on termination */ void *win32_reader(gpointer data) { gint fd = (GINT)data; gint errcount = 0; static gsize wanted = 2048; gboolean res = FALSE; gchar buf[2048]; gchar *ptr = NULL; gsize requested = 2048; gssize received = 0; gsize read_pos = 0; GIOStatus status; GError *err = NULL; GCond *cond = NULL; ENTER(); cond = (GCond *)DATA_GET(global_data,"serial_reader_cond"); while (TRUE) { if ((DATA_GET(global_data,"leaving")) || (DATA_GET(global_data,"serial_abort"))) { if (cond) g_cond_signal(cond); g_thread_exit(0); } read_pos = requested-wanted; received = read(fd, &buf[read_pos], wanted); g_usleep(10000); /*printf("Want %i, got %i,",wanted, received); */ if (received == -1) { DATA_SET(global_data,"connected",GINT_TO_POINTER(FALSE)); g_cond_signal(cond); g_thread_exit(0); } wanted -= received; /* printf("Still need %i\n",wanted); */ if (wanted <= 0) wanted = 2048; /*printf("WIN32 read %i bytes\n",received);*/ if (received > 0) handle_data((guchar *)buf+read_pos,received); g_cond_signal(cond); } EXIT(); return NULL; }
gpointer worker_run(GSList* nodes) { /* get current thread's private worker object */ Worker* worker = worker_getPrivate(); /* continuously run all events for this worker's assigned nodes. * the simulation is done when the engine is killed. */ while(!engine_isKilled(worker->cached_engine)) { SimulationTime barrier = engine_getExecutionBarrier(worker->cached_engine); guint nEventsProcessed = 0; guint nNodesWithEvents = 0; GSList* item = nodes; while(item) { Node* node = item->data; guint n = _worker_processNode(worker, node, barrier); nEventsProcessed += n; if(n > 0) { nNodesWithEvents++; } item = g_slist_next(item); } engine_notifyProcessed(worker->cached_engine, nEventsProcessed, nNodesWithEvents); } /* free all applications before freeing any of the nodes since freeing * applications may cause close() to get called on sockets which needs * other node information. */ g_slist_foreach(nodes, (GFunc) node_stopAllApplications, NULL); g_slist_foreach(nodes, (GFunc) node_free, NULL); g_thread_exit(NULL); return NULL; }
static gpointer stun_thread_func (const gpointer user_data) { StunAgent oldagent; StunAgent newagent; int sock; int exit_code = -1; sock = listen_socket (IPPORT_STUN); if (sock == -1) { g_assert_not_reached (); } stun_agent_init (&oldagent, known_attributes, STUN_COMPATIBILITY_RFC3489, 0); stun_agent_init (&newagent, known_attributes, STUN_COMPATIBILITY_RFC5389, STUN_AGENT_USAGE_USE_FINGERPRINT); while (!exit_stun_thread) { g_debug ("Ready to process next datagram"); dgram_process (sock, &oldagent, &newagent); } exit_code = close (sock); g_thread_exit (GINT_TO_POINTER (exit_code)); return NULL; }
static gpointer server_in_background (BackgroundData *data) { int argc = data->argc; char **argv = data->argv; CORBA_Object servant = CORBA_OBJECT_NIL; CORBA_char filename[] = "calculator.ref"; CORBA_Environment ev[1]; CORBA_exception_init(ev); server_init (&argc, argv, &global_orb, &default_poa, ev); etk_abort_if_exception(ev, "failed ORB init"); servant = server_activate_service (global_orb, default_poa, ev); etk_abort_if_exception(ev, "failed activating service"); g_print ("Writing service reference to: %s\n\n", filename); etk_export_object_to_file (global_orb, servant, filename, ev); etk_abort_if_exception(ev, "failed exporting IOR"); server_run (global_orb, ev); etk_abort_if_exception(ev, "failed entering main loop"); server_cleanup (global_orb, default_poa, servant, ev); etk_abort_if_exception(ev, "failed cleanup"); g_thread_exit (NULL); }
gpointer idle_thread_func(gpointer user_data) { PluginOption *option = ((ThreadData *)user_data)->option; int thread_index = ((ThreadData *)user_data)->index; int sock_type = SOCK_STREAM; if (sock_type_d) sock_type = SOCK_DGRAM; if (sock_type_s) sock_type = SOCK_STREAM; int fd; if (unix_socket_x) fd = connect_unix_domain_socket(sock_type, option->target); else fd = connect_ip_socket(sock_type, option->target, option->port, option->use_ipv6); if (fd<0) { ERROR("can not connect to %s:%s (%p)\n",option->target, option->port,g_thread_self()); } else { DEBUG("(%d) connected to server on socket %d (%p)\n",thread_index,fd,g_thread_self()); } g_mutex_lock(thread_lock); connect_finished++; if (connect_finished == active_thread_count + idle_thread_count) g_cond_broadcast(thread_connected); g_mutex_unlock(thread_lock); DEBUG("thread (%s,%p) created. wait for start ...\n",loggen_plugin_info.name,g_thread_self()); g_mutex_lock(thread_lock); while (!thread_run) { g_cond_wait(thread_start,thread_lock); } g_mutex_unlock(thread_lock); DEBUG("thread (%s,%p) started. (r=%d,c=%d)\n",loggen_plugin_info.name,g_thread_self(),option->rate, option->number_of_messages); while (fd > 0 && thread_run && active_thread_count>0) { g_usleep(10*1000); } g_mutex_lock(thread_lock); idle_thread_count--; g_mutex_unlock(thread_lock); close(fd); g_thread_exit(NULL); return NULL; }
static gpointer oh_event_thread_loop(gpointer data) { GTimeVal time; SaErrorT rv; g_mutex_lock(oh_thread_mutex); while(oh_run_threaded()) { trace("Thread Harvesting events"); rv = oh_harvest_events(); if(rv != SA_OK) { trace("Error on harvest of events."); } trace("Thread processing events"); rv = oh_process_events(); if(rv != SA_OK) { trace("Error on processing of events, aborting"); } trace("Thread processing hotswap"); process_hotswap_policy(); g_get_current_time(&time); g_time_val_add(&time, OH_THREAD_SLEEP_TIME); trace("Going to sleep"); if (g_cond_timed_wait(oh_thread_wait, oh_thread_mutex, &time)) trace("SIGNALED: Got signal from plugin"); else trace("TIMEDOUT: Woke up, am looping again"); } g_mutex_unlock(oh_thread_mutex); g_thread_exit(0); return data; }
static gpointer oh_discovery_thread_loop(gpointer data) { GTimeVal time; SaErrorT error = SA_OK; g_mutex_lock(oh_discovery_thread_mutex); while (1) { trace("Doing threaded discovery on all handlers"); error = oh_domain_resource_discovery(0); if (error) { trace("Got error on threaded discovery return."); } /* Let oh_wake_discovery_thread know this thread is done */ g_cond_broadcast(oh_discovery_thread_wait); g_get_current_time(&time); g_time_val_add(&time, OH_DISCOVERY_THREAD_SLEEP_TIME); /* Go to sleep; let oh_wake_discovery_thread take the mutex */ trace("Going to sleep"); if (g_cond_timed_wait(oh_discovery_thread_wait, oh_discovery_thread_mutex, &time)) trace("SIGNALED: Got signal from saHpiDiscover()"); else trace("TIMEDOUT: Woke up, am doing discovery again"); } g_mutex_unlock(oh_discovery_thread_mutex); g_thread_exit(0); return data; }
static gpointer _get_data_threaded (GldiTask *pTask) { g_mutex_lock (pTask->pMutex); _run_thread: // at this point the mutex is locked, either by the first execution of this function, or by 'g_cond_wait' //\_______________________ get the data _set_elapsed_time (pTask); pTask->get_data (pTask->pSharedMemory); // and signal that data are ready to be processed. pTask->bNeedsUpdate = TRUE; // this is only accessed by the update fonction, which is triggered just after, so no need to protect this variable. //\_______________________ call the update function from the main loop if (pTask->iSidUpdateIdle == 0) pTask->iSidUpdateIdle = g_idle_add ((GSourceFunc) _check_for_update_idle, pTask); // note that 'iSidUpdateIdle' can actually be set after the 'update' is called. that's why the 'update' have to wait for the mutex to finish its job. // sleep until the next iteration or just leave. if (pTask->pCond) // periodic task -> block until the condition becomes TRUE again. { pTask->bRunThread = FALSE; while (! pTask->bRunThread) g_cond_wait (pTask->pCond, pTask->pMutex); // releases the mutex, then takes it again when awakening. if (g_atomic_int_get (&pTask->bDiscard) == 0) goto _run_thread; } g_mutex_unlock (pTask->pMutex); g_thread_exit (NULL); return NULL; }
static void * run_test (void *threadid) { gint id = GPOINTER_TO_INT (threadid); while (TRUE) { if (id == 0) { gint res = gst_poll_wait (set, 10); if (res < 0) { g_print ("error %d %s\n", errno, g_strerror (errno)); } } else { mess_some_more (); if (g_timer_elapsed (timer, NULL) > 0.5) { g_mutex_lock (fdlock); g_print ("active fds :%d\n", g_list_length (fds)); g_timer_start (timer); g_mutex_unlock (fdlock); } g_usleep (1); } } g_thread_exit (NULL); return NULL; }
static gpointer stun_thread_func (const gpointer user_data) { StunAgent oldagent; StunAgent newagent; int sock = GPOINTER_TO_INT (user_data); int exit_code = -1; g_mutex_lock (stun_thread_mutex_ptr); g_cond_signal (stun_thread_signal_ptr); g_mutex_unlock (stun_thread_mutex_ptr); stun_agent_init (&oldagent, known_attributes, STUN_COMPATIBILITY_RFC3489, 0); stun_agent_init (&newagent, known_attributes, STUN_COMPATIBILITY_RFC5389, STUN_AGENT_USAGE_USE_FINGERPRINT); while (!exit_stun_thread) { g_debug ("Ready to process next datagram"); dgram_process (sock, &oldagent, &newagent); } exit_code = close (sock); g_thread_exit (GINT_TO_POINTER (exit_code)); return NULL; }
static void * run_test (void *user_data) { gint threadid = GPOINTER_TO_INT (user_data); guint64 nb; GstBuffer *buf; GstClockTime start, end; g_mutex_lock (mutex); g_mutex_unlock (mutex); start = gst_util_get_timestamp (); g_assert (nbbuffers > 0); for (nb = nbbuffers; nb; nb--) { buf = gst_buffer_new (); gst_buffer_unref (buf); } end = gst_util_get_timestamp (); g_print ("total %" GST_TIME_FORMAT " - average %" GST_TIME_FORMAT " - Thread %d\n", GST_TIME_ARGS (end - start), GST_TIME_ARGS ((end - start) / nbbuffers), threadid); g_thread_exit (NULL); return NULL; }
gpointer upload(gpointer arg) { #if 0 gtk_widget_hide(mtp_submenu_item_free); #endif if(!mutex) { #if 0 gtk_label_set_text(GTK_LABEL(gtk_bin_get_child(GTK_BIN(mtp_submenu_item_up))),UP_DEFAULT_LABEL); gtk_widget_set_sensitive(mtp_submenu_item_up, TRUE); #endif return NULL; } g_mutex_lock(mutex); if(!mtp_device) { #if 0 gtk_label_set_text(GTK_LABEL(gtk_bin_get_child(GTK_BIN(mtp_submenu_item_up))),UP_DEFAULT_LABEL); gtk_widget_set_sensitive(mtp_submenu_item_up, TRUE); #endif g_mutex_unlock(mutex); return NULL; } Tuple* tuple; GList *up_list=NULL,*node; node=up_list=get_upload_list(); gint up_err=0; while(node) { tuple=(Tuple*)(node->data); up_err = upload_file(tuple); if(up_err ) { /*show_dialog("An error has occured while uploading...\nUpload failed!");*/ break; } if(exiting) { /*show_dialog("Shutting down MTP while uploading.\nPending uploads were cancelled");*/ break; } node = g_list_next(node); } g_list_free(up_list); #if 0 gtk_label_set_text(GTK_LABEL(gtk_bin_get_child(GTK_BIN(mtp_submenu_item_up))),UP_DEFAULT_LABEL); gtk_widget_set_sensitive(mtp_submenu_item_up, TRUE); #endif g_mutex_unlock(mutex); #if DEBUG g_print("MTP upload process finished\n"); #endif #if 0 gtk_widget_show(mtp_submenu_item_free); #endif g_thread_exit(NULL); return NULL; }
void mmsvc_core_worker_exit(Client client) { LOGD("Enter"); if (!client) { LOGE("Error - null client"); return; } mmsvc_core_connection_close(client->ch[MUSED_CHANNEL_MSG].fd); mmsvc_core_connection_close(client->ch[MUSED_CHANNEL_DATA].fd); if (!client->ch[MUSED_CHANNEL_MSG].p_gthread) { LOGE("Error - null p_gthread"); return; } LOGD("%p thread exit\n", client->ch[MUSED_CHANNEL_MSG].p_gthread); g_thread_unref(client->ch[MUSED_CHANNEL_MSG].p_gthread); if (client->ch[MUSED_CHANNEL_DATA].p_gthread) g_thread_unref(client->ch[MUSED_CHANNEL_DATA].p_gthread); MMSVC_FREE(client); mmsvc_core_config_get_instance()->free(); LOGD("Leave"); g_thread_exit(NULL); }
/* * _thread_handle_signals() * * Trap linux signals for the whole multi-threaded application. * * Params: * main_loop -- closing this shuts down the app orderly * * Returns/Affects: * returns and/or set the atomic gint gd_flag_exit * returns last signal */ static gpointer _thread_handle_signals(gpointer main_loop) { sigset_t signal_set; siginfo_t signal_info; gint sig = 0; gint rval = 0; sigfillset (&signal_set); g_debug("signal handler: startup successful"); while (g_atomic_int_get(&gd_flag_exit)) { /* wait for any and all signals */ sig = sigwaitinfo (&signal_set, &signal_info); if (!sig) { g_message("signal handler: sigwaitinfo() returned an error => {%s}", g_strerror(errno)); continue; } /* when we get this far, we've caught a signal */ rval = _process_signals ( &signal_info ); g_atomic_int_set(&gd_flag_exit, rval); } /* end-while */ g_main_loop_quit(main_loop); pthread_sigmask (SIG_UNBLOCK, &signal_set, NULL); g_debug("signal handler: shutdown complete"); g_thread_exit ( GINT_TO_POINTER(sig) ); return (NULL); }
/* Progress bar implementation */ static void* progress_bar(void *unused) { GTimeVal time; char buf[PROGRESS_BUF_SIZE], A[20]; int i = 0, t = 0, len, mes_len; memset(buf, 0, PROGRESS_BUF_SIZE); mes_len = strlen(progress_mes); while (in_progress) { snprintf(A, 10, " %d.%d s ", t / 10, t % 10); len = strlen(A); memset(buf + mes_len, '.', i); strncpy(buf, progress_mes, mes_len); if (i > 8) strncpy(buf + mes_len + (i - len) / 2, A, len); printf("%s\r", buf); fflush(stdout); g_get_current_time(&time); g_time_val_add(&time, G_USEC_PER_SEC / 10); g_cond_timed_wait(thread_wait, thread_mutex, &time); if (i < (PROGRESS_BUF_SIZE - mes_len - 1)) i++; t++; }; g_thread_exit(0); return (void *)1; }
/** * Function to optimize on a thread. * * \return NULL. */ static void * optimize_thread (ParallelData * data) ///< Function data. { unsigned int i, thread; double e; #if DEBUG_OPTIMIZE fprintf (stderr, "optimize_thread: start\n"); #endif thread = data->thread; #if DEBUG_OPTIMIZE fprintf (stderr, "optimize_thread: thread=%u start=%u end=%u\n", thread, optimize->thread[thread], optimize->thread[thread + 1]); #endif for (i = optimize->thread[thread]; i < optimize->thread[thread + 1]; ++i) { e = optimize_norm (i); g_mutex_lock (mutex); optimize_best (i, e); optimize_save_variables (i, e); if (e < optimize->threshold) optimize->stop = 1; g_mutex_unlock (mutex); if (optimize->stop) break; #if DEBUG_OPTIMIZE fprintf (stderr, "optimize_thread: i=%u e=%lg\n", i, e); #endif } #if DEBUG_OPTIMIZE fprintf (stderr, "optimize_thread: end\n"); #endif g_thread_exit (NULL); return NULL; }
static void main_loop_thread () { _mb_global_data.loop = g_main_loop_new (NULL, FALSE); g_main_loop_run (_mb_global_data.loop); g_thread_exit (0); }
static gpointer oh_event_thread_loop(gpointer data) { GTimeVal time; SaErrorT error = SA_OK; static int first_loop = 1; g_mutex_lock(oh_event_thread_mutex); while (1) { /* Give the discovery time to start first -> FIXME */ if (first_loop) { struct timespec sleepytime = { .tv_sec = 0, .tv_nsec = 500000000}; first_loop = 0; nanosleep(&sleepytime, NULL); } trace("Thread Harvesting events"); error = oh_harvest_events(); if (error != SA_OK) dbg("Error on harvest of events."); trace("Thread processing events"); error = oh_process_events(); if (error != SA_OK) dbg("Error on processing of events."); /* Let oh_wake_event_thread know this thread is done */ g_cond_broadcast(oh_event_thread_wait); g_get_current_time(&time); g_time_val_add(&time, OH_EVENT_THREAD_SLEEP_TIME); trace("Going to sleep"); if (g_cond_timed_wait(oh_event_thread_wait, oh_event_thread_mutex, &time)) trace("SIGNALED: Got signal from plugin"); else trace("TIMEDOUT: Woke up, am looping again"); } g_mutex_unlock(oh_event_thread_mutex); g_thread_exit(0); return data; } int oh_threaded_init() { int error = 0; trace("Attempting to init event"); if (!g_thread_supported()) { trace("Initializing thread support"); g_thread_init(NULL); } else { trace("Already supporting threads"); } error = oh_discovery_init(); if (oh_event_init() || error) error = 1; return error; }
static gpointer thd2(gpointer data) { arg_t *arg = data; get_ble_tree(2, arg->mac, arg->file_path); g_thread_exit(0); return NULL; }
static gpointer run_main_loop(gpointer data) { while (running) g_main_context_iteration(ctx, TRUE); g_thread_exit(NULL); return NULL; }
static gpointer enable_ctx_thread (gpointer user_data) { if ( !XRecordEnableContext (grab_info->data_disp, grab_info->context, grab_key_event_cb, NULL) ) { g_warning ("Unable to enable context..."); grab_xrecord_finalize (); } g_thread_exit (NULL); }
/** * glk_exit: * * If you want to shut down your program in the middle of your `glk_main()` * function, you can call glk_exit(). * * This function does not return. * * If you print some text to a window and then shut down your program, you can * assume that the player will be able to read it. Most likely the Glk library * will give a “`Hit any key to exit`” prompt. * (There are other possiblities, however. * A terminal-window version of Glk might simply exit and leave the last screen * state visible in the terminal window.) * * <note><para> * You should only shut down your program with glk_exit() or by returning from * your <function>glk_main()</function> function. If you call the ANSI * <function>exit()</function> function, bad things may happen. Some versions of * the Glk library may be designed for multiple sessions, for example, and you * would be cutting off all the sessions instead of just yours. You would * probably also prevent final text from being visible to the player. * </para></note> * * > # Chimara # * > If there are any windows open at the time glk_exit() is called, then * > Chimara will leave them open. * > This way, the final text remains visible. * > Note that bad things most definitely <emphasis>will</emphasis> happen if * > you use the ANSI `exit()`. */ void glk_exit(void) { ChimaraGlkPrivate *glk_data = g_private_get(&glk_data_key); shutdown_glk_pre(); /* Find the biggest text buffer window */ winid_t win, largewin = NULL; glui32 largearea = 0; for(win = glk_window_iterate(NULL, NULL); win; win = glk_window_iterate(win, NULL)) { if(win->type == wintype_TextBuffer) { glui32 w, h; if(!largewin) { largewin = win; glk_window_get_size(largewin, &w, &h); largearea = w * h; } else { glk_window_get_size(win, &w, &h); if(w * h > largearea) { largewin = win; largearea = w * h; } } } } if(largewin) { glk_set_window(largewin); glk_set_style(style_Alert); glk_put_string("\n"); glk_put_string(glk_data->final_message); glk_put_string("\n"); flush_window_buffer(largewin); } /* Wait for a keypress if any text grid or buffer windows are open */ gboolean should_wait = FALSE; g_mutex_lock(&glk_data->shutdown_lock); for(win = glk_window_iterate(NULL, NULL); win; win = glk_window_iterate(win, NULL)) { if(win->type == wintype_TextGrid || win->type == wintype_TextBuffer) { g_signal_handler_unblock(win->widget, win->shutdown_keypress_handler); should_wait = TRUE; } } if (should_wait) g_cond_wait(&glk_data->shutdown_key_pressed, &glk_data->shutdown_lock); g_mutex_unlock(&glk_data->shutdown_lock); shutdown_glk_post(); gdk_threads_add_idle((GSourceFunc)emit_stopped_signal, glk_data->self); g_thread_exit(NULL); }
static void gimp_fonts_load_thread (GimpFontsLoadFuncData *data) { gimp_fonts_load_func (data->config); g_mutex_lock (&data->mutex); data->caching_complete = TRUE; g_cond_signal (&data->cond); g_mutex_unlock (&data->mutex); g_thread_exit (0); }
static gpointer testServerMonitorThreadFunc(gpointer) { // Wait for the specified timeout to happen. g_usleep(gMaxWaitForChild * G_USEC_PER_SEC); // Kill the child process if not ready yet. if (!gChildIsReady) stopTestServer(); g_thread_exit(0); return 0; }
/* * Event loop thread */ static gpointer _event_thread(gpointer data) { printf_dbg("Event loop START\n"); g_mutex_lock(cb_mutex); event_loop = g_main_loop_new(NULL, FALSE); g_mutex_unlock(cb_mutex); g_main_loop_run(event_loop); g_main_loop_unref(event_loop); event_loop = NULL; printf_dbg("Event loop EXIT\n"); g_thread_exit(0); return 0; }
static gpointer rejilla_checksum_files_thread (gpointer data) { GError *error = NULL; RejillaJobAction action; RejillaChecksumFiles *self; RejillaTrack *current = NULL; RejillaChecksumFilesPrivate *priv; RejillaChecksumFilesThreadCtx *ctx; RejillaBurnResult result = REJILLA_BURN_NOT_SUPPORTED; self = REJILLA_CHECKSUM_FILES (data); priv = REJILLA_CHECKSUM_FILES_PRIVATE (self); /* check DISC types and add checksums for DATA and IMAGE-bin types */ rejilla_job_get_action (REJILLA_JOB (self), &action); rejilla_job_get_current_track (REJILLA_JOB (self), ¤t); if (action == REJILLA_JOB_ACTION_CHECKSUM) { priv->checksum_type = rejilla_track_get_checksum_type (current); if (priv->checksum_type & (REJILLA_CHECKSUM_MD5_FILE|REJILLA_CHECKSUM_SHA1_FILE|REJILLA_CHECKSUM_SHA256_FILE|REJILLA_CHECKSUM_DETECT)) result = rejilla_checksum_files_check_files (self, &error); else result = REJILLA_BURN_ERR; } else if (action == REJILLA_JOB_ACTION_IMAGE) { if (REJILLA_IS_TRACK_DATA (current)) result = rejilla_checksum_files_create_checksum (self, &error); else result = REJILLA_BURN_ERR; } if (result != REJILLA_BURN_CANCEL) { ctx = g_new0 (RejillaChecksumFilesThreadCtx, 1); ctx->sum = self; ctx->error = error; ctx->result = result; priv->end_id = g_idle_add_full (G_PRIORITY_HIGH_IDLE, rejilla_checksum_files_end, ctx, rejilla_checksum_files_destroy); } /* End thread */ g_mutex_lock (priv->mutex); priv->thread = NULL; g_cond_signal (priv->cond); g_mutex_unlock (priv->mutex); g_thread_exit (NULL); return NULL; }
gpointer start_single_dcp_thread(gpointer _thread_info) { ThreadInfo* t = _thread_info; RS_IMAGE16 *tmp = t->tmp; pre_cache_tables(t->dcp); if (tmp->pixelsize == 4 && (rs_detect_cpu_features() & RS_CPU_FLAG_SSE2) && !t->dcp->read_out_curve) { if ((rs_detect_cpu_features() & RS_CPU_FLAG_AVX) && render_AVX(t)) { /* AVX routine renders 4 pixels in parallel, but any remaining must be */ /* calculated using C routines */ if (tmp->w & 3) { t->start_x = tmp->w - (tmp->w & 3); render(t); } } else if ((rs_detect_cpu_features() & RS_CPU_FLAG_SSE4_1) && render_SSE4(t)) { /* SSE4 routine renders 4 pixels in parallel, but any remaining must be */ /* calculated using C routines */ if (tmp->w & 3) { t->start_x = tmp->w - (tmp->w & 3); render(t); } } else if (render_SSE2(t)) { /* SSE2 routine renders 4 pixels in parallel, but any remaining must be */ /* calculated using C routines */ if (tmp->w & 3) { t->start_x = tmp->w - (tmp->w & 3); render(t); } } else { /* Not SSE2 compiled, render using plain C */ render(t); } } else render(t); if (!t->single_thread) g_thread_exit(NULL); return NULL; /* Make the compiler shut up - we'll never return */ }
static void check_afc(gpointer data) { //prepare a buffer unsigned int buffersize = BUFFER_SIZE * sizeof(unsigned int); int *buf = (int *) malloc(buffersize); int *buf2 = (int *) malloc(buffersize); unsigned int bytes = 0; uint64_t position = 0; //fill buffer int i = 0; for (i = 0; i < BUFFER_SIZE; i++) { buf[i] = ((param *) data)->id * i; } //now writes buffer on device uint64_t file = 0; char path[50]; sprintf(path, "/Buf%i", ((param *) data)->id); afc_file_open(((param *) data)->afc, path, AFC_FOPEN_RW, &file); afc_file_write(((param *) data)->afc, file, (char *) buf, buffersize, &bytes); afc_file_close(((param *) data)->afc, file); file = 0; if (bytes != buffersize) printf("Write operation failed\n"); //now read it bytes = 0; afc_file_open(((param *) data)->afc, path, AFC_FOPEN_RDONLY, &file); afc_file_read(((param *) data)->afc, file, (char *) buf2, buffersize/2, &bytes); afc_file_read(((param *) data)->afc, file, (char *) buf2 + (buffersize/2), buffersize/2, &bytes); if(AFC_E_SUCCESS != afc_file_tell(((param *) data)->afc, file, &position)) printf("Tell operation failed\n"); afc_file_close(((param *) data)->afc, file); if (position != buffersize) printf("Read operation failed\n"); //compare buffers for (i = 0; i < BUFFER_SIZE; i++) { if (buf[i] != buf2[i]) { printf("Buffers are differents, stream corrupted\n"); break; } } //cleanup afc_remove_path(((param *) data)->afc, path); g_thread_exit(0); }