int main(int argc, char *argv[]) { int err; if (argc > 2) { show_usage(argv[0]); exit(-1); } if (argc == 2) test_duration = atoi(argv[1]); setup_handlers(); printf("faulting for %u seconds . . .\n", test_duration); err = alarm(test_duration); assert(err == 0); err = clock_gettime(CLOCK_REALTIME, &time_start); assert(err == 0); do_faults(); /* should never reach here */ return EXIT_FAILURE; }
int main(int argc, char *argv[]) { int ret = 0; setup_handlers(); if (ws2811_init(&ledstring)) { return -1; } while (1) { matrix_raise(); matrix_bottom(); matrix_render(); if (ws2811_render(&ledstring)) { ret = -1; break; } // 15 frames /sec usleep(1000000 / 15); } ws2811_fini(&ledstring); return ret; }
int main(int argc, char* argv[]){ if(argc < 2){ printf("Not enough input arguments!\n"); printf("Usage: %s filename\n", argv[0]); return -1; } loadImage(&image, argv[1]); cropToSquare(&image); uint16_t numSlices = (REFRESH_RATE * 60) / ROTATION_RATE; ws2811_init(&ledstring); setup_handlers(); unsigned int updatesCompleted = 0; double th; #ifdef PERFCOUNT struct timespec start, end; printf("Update rate:\n"); if(clock_gettime(CLOCK_REALTIME, &start)) { EPRINT("Error: Couldnt get clock time!"); } #endif while(running) { th = (updatesCompleted % numSlices) * 2 * M_PI / numSlices; generateSlice(ledstring.channel[0].leds, th, image.height); if (ws2811_render(&ledstring)) { EPRINT("Error: Rendering string didnt return 0!\n"); break; } updatesCompleted += 1; #ifdef PERFCOUNT if(!(updatesCompleted % 300)) { if(clock_gettime(CLOCK_REALTIME, &end)) { EPRINT("Error: Couldnt get clock time!"); } double freq = 300000.0/((end.tv_sec - start.tv_sec)*1000 + (end.tv_nsec - start.tv_nsec)/1000000); printf("\t%.2f Hz\r", freq); fflush(stdout); start = end; } #endif } // Clear the led strip before exiting for(int i = 0; i < LED_COUNT; i++) { ledstring.channel[0].leds[i] = 0; } ws2811_render(&ledstring); ws2811_fini(&ledstring); }
void dmtcp_event_hook(DmtcpEvent_t event, DmtcpEventData_t *data) { static char *filename = NULL; static bool restartingFromCkpt = false; static FILE *outfp = NULL; switch (event) { case DMTCP_EVENT_INIT: { if (!getenv("DMTCP_START_CTRS_ON_RESTART_STRATEGY")) { setup_handlers(); filename = getStatsFilename(getenv("STATFILE")); JWARNING(filename != NULL).Text("Could not get the stats filename in the init event."); JTRACE("Filename: ")(filename); } } break; case DMTCP_EVENT_WRITE_CKPT: { JTRACE("CHKP"); if (getenv("DMTCP_START_CTRS_ON_RESTART_STRATEGY")) { filename = getenv("STATFILE"); if (restartingFromCkpt) { JTRACE("WRITE CHKP"); JASSERT(filename); outfp = fopen(filename, "w+"); if (!outfp) { perror("Error opening stats file in w+ mode"); JASSERT(false); } read_ctrs(outfp); fclose(outfp); restartingFromCkpt = false; } } } break; case DMTCP_EVENT_RESUME: { if (getenv("DMTCP_KILL_ON_RESUME_STRATEGY")) { exit(0); } } break; case DMTCP_EVENT_RESTART: { if (getenv("DMTCP_START_CTRS_ON_RESTART_STRATEGY")) { restartingFromCkpt = true; filename = getStatsFilename(getenv("STATFILE")); JWARNING(filename != NULL).Text("Could not get the stats filename in the restart event."); JTRACE("Filename: ")(filename); JWARNING(setup_perf_ctr()).Text("Error setting up perf ctrs."); } } break; case DMTCP_EVENT_RESUME_USER_THREAD: { if (getenv("DMTCP_START_CTRS_ON_RESTART_STRATEGY")) { filename = getStatsFilename(getenv("STATFILE")); JWARNING(filename != NULL).Text("Could not get the stats filename in the resume_user_thread event."); JTRACE("Filename: ")(filename); } } break; default: break; } DMTCP_NEXT_EVENT_HOOK(event, data); }
/// Constructor that sets up the signal handlers. signals::interrupts_handler::interrupts_handler(void) { PRE(!interrupts_handler_active); setup_handlers(); interrupts_handler_active = true; }
int main(int argc, char *argv[]) { Q_INIT_RESOURCE(commonrc); Q_INIT_RESOURCE(translations); if(SingleApplication::sendMessage(QObject::tr("An instance of Qcma is already running"))) { return 0; } SingleApplication app(argc, argv); #ifndef Q_OS_WIN32 // FIXME: libmtp sends SIGPIPE if a socket write fails crashing the whole app // the proper fix is to libmtp to handle the cancel properly or ignoring // SIGPIPE on the socket signal(SIGPIPE, SIG_IGN); setup_handlers(); #endif if(app.arguments().contains("--with-debug")) { VitaMTP_Set_Logging(VitaMTP_DEBUG); } else if(app.arguments().contains("--verbose")) { VitaMTP_Set_Logging(VitaMTP_VERBOSE); } else { VitaMTP_Set_Logging(VitaMTP_NONE); #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) qInstallMessageHandler(noMessageOutput); #else qInstallMsgHandler(noMessageOutput); #endif } #if QT_VERSION < QT_VERSION_CHECK(5, 0, 0) QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8")); #endif QTextStream(stdout) << "Starting Qcma " << QCMA_VER << endl; QTranslator translator; QString locale = QLocale().system().name(); qDebug() << "Current locale:" << locale; if(app.arguments().contains("--set-locale")) { int index = app.arguments().indexOf("--set-locale"); if(index + 1 < app.arguments().length()) { qDebug("Enforcing locale: %s", app.arguments().at(index + 1).toUtf8().data()); locale = app.arguments().at(index + 1); } } if(translator.load("qcma_" + locale, ":/resources/translations")) { app.installTranslator(&translator); } else { qWarning() << "Cannot load translation for locale:" << locale; } QTranslator system_translator; system_translator.load("qt_" + locale, QLibraryInfo::location(QLibraryInfo::TranslationsPath)); app.installTranslator(&system_translator); qDebug("Starting main thread: 0x%016" PRIxPTR, (uintptr_t)QThread::currentThreadId()); // set the organization/application for QSettings to work properly app.setOrganizationName("codestation"); app.setApplicationName("qcma"); //TODO: check if this is actually needed since we don't have a main window by default QApplication::setQuitOnLastWindowClosed(false); bool showSystray = !app.arguments().contains("--no-systray"); MainWidget widget; widget.prepareApplication(showSystray); // receive the message from another process QObject::connect(&app, SIGNAL(messageAvailable(QString)), &widget, SLOT(receiveMessage(QString))); return app.exec(); }
/* main multicore function */ int go_multi_core(char* filename) { pid_t child_pids[MAX_PROC]; int i,fd; struct shmstruct *ptr; cpu_set_t mask; /* Setting up main process shared memory */ shm_unlink(TMP_FNAME); /* delete previous file */ fd = shm_open(TMP_FNAME, O_RDWR | O_CREAT | O_EXCL, S_IRWXU); /* open */ if ( (ptr = mmap(NULL, sizeof(struct shmstruct), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED) { log("cannot map memory :("); exit (-1); }; ftruncate(fd, sizeof(struct shmstruct)); /* resize */ close(fd); /* close fd */ log("Size of memory: %ldM, handle %ld, addr: %lx", sizeof(struct shmstruct)/(1<<20), sizeof(pkt_handle), (long unsigned int) ptr); /* initialize sempaphores in shared memory */ sem_init(&(ptr->pstart_sem), 1, 0); sem_init(&(ptr->nvmsetup_sem), 1, 0); sem_init(&(ptr->log_sem), 1, 1); /* setup some handlers to get children initialization end*/ setup_handlers(); log("starting copying capture"); /* copy capture in memory */ copy_capture(ptr); log("copied capture into memory"); /* for each child */ for (i = 0; i < ConfigParams.ncores; i++) { /* fork */ log("Forking child %d", i); if ((child_pids[i] = fork()) >= 0) { if (child_pids[i] == 0) { /* kid */ CPU_ZERO(&mask); CPU_SET(i, &mask); /* bind each child to a single core */ if (sched_setaffinity(0, sizeof(mask), &mask) == -1) { log("setaffinity badly dead"); exit (-1); } prctl(PR_SET_PDEATHSIG, SIGHUP); /* if parent dies, we die too */ child_n = i; log("Child %d, pid %d", i, getpid()); /* setup netmv */ NetVMSetup(filename, ptr, i); break; } else { /* parent */ continue; } }; } /* log ("Freeing rule options"); */ /* rule_free_options (sdata.rules); */ /* wait children to finish netvm setup */ for (i = 0 ; i < ConfigParams.ncores; i++) { log("%d processes finished setting up nvm", i); sem_wait(&(ptr->nvmsetup_sem) ); } log("continuing"); /* now i tell kids to start */ for (i = 0; i < ConfigParams.ncores; i++) { sem_post(&(ptr->pstart_sem) ); } /* finally wait packet processing */ while(!netvm_termination) sleep(1); log_close(); return 0; }
/* * called to create a new server task */ static void prefork_new_task( struct tevent_context *ev, struct loadparm_context *lp_ctx, const char *service_name, void (*new_task_fn)(struct tevent_context *, struct loadparm_context *lp_ctx, struct server_id , void *, void *), void *private_data, const struct service_details *service_details, int from_parent_fd) { pid_t pid; struct tfork* t = NULL; int i, num_children; struct tevent_context *ev2; t = tfork_create(); if (t == NULL) { smb_panic("failure in tfork\n"); } pid = tfork_child_pid(t); if (pid != 0) { struct tevent_fd *fde = NULL; int fd = tfork_event_fd(t); /* Register a pipe handler that gets called when the prefork * master process terminates. */ fde = tevent_add_fd(ev, ev, fd, TEVENT_FD_READ, prefork_child_pipe_handler, t); if (fde == NULL) { smb_panic("Failed to add child pipe handler, " "after fork"); } tevent_fd_set_auto_close(fde); return; } pid = getpid(); setproctitle("task[%s] pre-fork master", service_name); /* * this will free all the listening sockets and all state that * is not associated with this new connection */ if (tevent_re_initialise(ev) != 0) { smb_panic("Failed to re-initialise tevent after fork"); } prefork_reload_after_fork(); setup_handlers(ev, from_parent_fd); if (service_details->inhibit_pre_fork) { new_task_fn(ev, lp_ctx, cluster_id(pid, 0), private_data, NULL); /* The task does not support pre-fork */ tevent_loop_wait(ev); TALLOC_FREE(ev); exit(0); } /* * This is now the child code. We need a completely new event_context * to work with */ ev2 = s4_event_context_init(NULL); /* setup this new connection: process will bind to it's sockets etc * * While we can use ev for the child, which has been re-initialised * above we must run the new task under ev2 otherwise the children would * be listening on the sockets. Also we don't want the top level * process accepting and handling requests, it's responsible for * monitoring and controlling the child work processes. */ new_task_fn(ev2, lp_ctx, cluster_id(pid, 0), private_data, NULL); { int default_children; default_children = lpcfg_prefork_children(lp_ctx); num_children = lpcfg_parm_int(lp_ctx, NULL, "prefork children", service_name, default_children); } if (num_children == 0) { DBG_WARNING("Number of pre-fork children for %s is zero, " "NO worker processes will be started for %s\n", service_name, service_name); } DBG_NOTICE("Forking %d %s worker processes\n", num_children, service_name); /* We are now free to spawn some worker processes */ for (i=0; i < num_children; i++) { struct tfork* w = NULL; w = tfork_create(); if (w == NULL) { smb_panic("failure in tfork\n"); } pid = tfork_child_pid(w); if (pid != 0) { struct tevent_fd *fde = NULL; int fd = tfork_event_fd(w); fde = tevent_add_fd(ev, ev, fd, TEVENT_FD_READ, prefork_child_pipe_handler, w); if (fde == NULL) { smb_panic("Failed to add child pipe handler, " "after fork"); } tevent_fd_set_auto_close(fde); } else { /* tfork uses malloc */ free(w); TALLOC_FREE(ev); setproctitle("task[%s] pre-forked worker", service_name); prefork_reload_after_fork(); setup_handlers(ev2, from_parent_fd); tevent_loop_wait(ev2); talloc_free(ev2); exit(0); } } /* Don't listen on the sockets we just gave to the children */ tevent_loop_wait(ev); TALLOC_FREE(ev); /* We need to keep ev2 until we're finished for the messaging to work */ TALLOC_FREE(ev2); exit(0); }
//main routine int main(int argc, char *argv[]){ int ret = 0; int i; int index=0; ledstring.device=NULL; command_line = NULL; named_pipe_file=NULL; malloc_command_line(DEFAULT_COMMAND_LINE_SIZE); setup_handlers(); input_file = stdin; //by default we read from console, stdin mode = MODE_STDIN; if (argc>1){ if (strcmp(argv[1], "-p")==0){ //use a named pipe, creates a file (by default in /dev/ws281x) which you can write commands to: echo "command..." > /dev/ws281x if (argc>2){ named_pipe_file = malloc(strlen(argv[2]+1)); strcpy(named_pipe_file,argv[2]); }else{ named_pipe_file = malloc(strlen(DEFAULT_DEVICE_FILE)+1); strcpy(named_pipe_file, DEFAULT_DEVICE_FILE); } printf ("Opening %s as named pipe.", named_pipe_file); remove(named_pipe_file); mkfifo(named_pipe_file,0777); chmod(named_pipe_file,0777); input_file = fopen(named_pipe_file, "r"); mode = MODE_NAMED_PIPE; }else if (strcmp(argv[1], "-f")==0){ //read commands / data from text file if (argc>2){ input_file = fopen(argv[2], "r"); printf("Opening %s.", argv[2]); }else{ printf("Error you must enter a file name after -f option\n"); exit(1); } mode = MODE_FILE; }else if (strcmp(argv[1], "-tcp")==0){ //open up tcp ip port and read commands from there if (argc>2){ int port = atoi(argv[2]); if (port==0) port=9999; printf("Listening on %d.\n", port); start_tcpip(port); }else{ printf("You must enter a port after -tcp option\n"); exit(1); } mode = MODE_TCP; } } if ((mode == MODE_FILE || mode == MODE_NAMED_PIPE) && input_file==NULL){ perror("Error opening file!"); exit(1); } int c; while (exit_program==0) { if (mode==MODE_TCP){ c = 0; if (read(active_socket, (void *) & c, 1)<=0) c = EOF; //returns 0 if connection is closed, -1 if no more data available and >0 if data read }else{ c = fgetc (input_file); //doesn't work with tcp } if (c!=EOF){ process_character(c); }else{ //end of file or read error switch (mode){ case MODE_TCP: if (!exit_program){ tcp_wait_connection(); //go back to wait for connection } break; case MODE_NAMED_PIPE: case MODE_STDIN: usleep(10000); break; case MODE_FILE: exit_program=1; break; } } } if (mode==MODE_TCP){ shutdown(active_socket,SHUT_RDWR); shutdown(sockfd,SHUT_RDWR); close(active_socket); close(sockfd); }else{ fclose(input_file); } if (named_pipe_file!=NULL){ remove(named_pipe_file); free(named_pipe_file); } free(command_line); if (thread_data!=NULL) free(thread_data); if (ledstring.device!=NULL) ws2811_fini(&ledstring); return ret; }