void *ao_thread_func( void *arg ) { // Wait for signal while(1) { pthread_mutex_lock( &bufmutex ); pthread_cond_wait( &buftrig, &bufmutex ); if( buffer_ready ) { // Send the buffer to ao ao_play( dev, output_buffer, bytes_in_buffer ); debugp( DEBUGP_DEFAULT, 7, "playing\n" ); memset( output_buffer, 0, bytes_in_buffer ); buffer_ready = 0; } else { debugp( DEBUGP_DEFAULT, 7, "notready\n" ); } pthread_cond_signal( &buftrig ); pthread_mutex_unlock( &bufmutex ); } pthread_mutex_unlock( &bufmutex ); pthread_exit(NULL); }
void init_ao( session_t *sess ) { if( ao_thread != 0 ) return; ao_initialize(); output_buffer_size = 4 * (sess->frame_size+3); output_buffer = malloc(output_buffer_size); int driver; if (libao_driver) { // if a libao driver is specified on the command line, use that driver = ao_driver_id(libao_driver); if (driver == -1) { debugp( DEBUGP_DEFAULT, 0, "Could not find requested ao driver" ); kill( getpid(), SIGINT ); } } else { // otherwise choose the default driver = ao_default_driver_id(); } ao_sample_format fmt; memset(&fmt, 0, sizeof(fmt)); fmt.bits = 16; fmt.rate = sess->sample_rate; fmt.channels = NUM_CHANNELS; fmt.byte_format = AO_FMT_NATIVE; ao_option *ao_opts = NULL; if(libao_deviceid) { ao_append_option(&ao_opts, "id", libao_deviceid); } else if(libao_devicename){ ao_append_option(&ao_opts, "dev", libao_devicename); // Old libao versions (for example, 0.8.8) only support // "dsp" instead of "dev". ao_append_option(&ao_opts, "dsp", libao_devicename); } dev = ao_open_live(driver, &fmt, ao_opts); if (dev == NULL) { debugp( DEBUGP_DEFAULT, 0, "Could not open ao device (%d)", errno); kill( getpid(), SIGINT ); } if(pthread_create( &ao_thread, NULL, ao_thread_func, NULL )) { debugp( DEBUGP_DEFAULT, 0, "Could not start ao_thread\n" ); kill( getpid(), SIGINT ); } return; }
static int read_route_socket(char *s, int max) { int rv, to_read; struct rt_msghdr *rhdr; struct pollfd pfd; pfd.fd = route_socket; pfd.events = POLLRDNORM; pfd.revents = 0; errno = 0; do { rv = poll(&pfd, 1, 100); } while (rv == -1 && errno == EINTR); if (rv < 1) { if (rv == 0) { fatalp("read_route_socket: poll timeout\n"); } else fatalp("read_route_socket: poll: %s", strerror(errno)); return 0; } do { rv = recv(route_socket, s, max, MSG_PEEK); } while(rv == -1 && errno == EINTR); if (rv < 1) { debugp("read_route_socket: recv error\n"); return 0; } if (rv > max) { rv = max; debugp("read_route_socket: rv > max\n"); } rhdr = (struct rt_msghdr *)s; to_read = rhdr->rtm_msglen > max ? max : rhdr->rtm_msglen; rv = 0; do { rv += recv(route_socket, s, to_read - rv, 0); } while (rv != to_read); return rv; }
int main( int argc, char *argv[] ) { struct timeval main_start; gettimeofday(&main_start,NULL); int retval = 0; parse_args( argc, argv ); switch(function) { case command_line: retval = command_line_function(); break; case optimization: retval = optimize(); break; default: retval = command_line_function(); break; } struct timeval main_end; gettimeofday(&main_end,NULL); double dbegin = (double)main_start.tv_sec + (double)main_start.tv_usec / 1000000.0; double dnow = (double)main_end.tv_sec + (double)main_end.tv_usec / 1000000.0; double main_exec_time = dnow - dbegin; debugp( 2, "main() executed in %f seconds\n", main_exec_time ); return retval; }
/* Funcion que carga una base de datos desde un archivo * NOTE: Agrega a la lista ya existente, no BORRA lo que hay * en la lista actual. * REQUIRES: * fname != NULL * RETURNS: * true if success * false otherwise */ bool UDataBase::loadFromFile (const char * fname) { FILE * fd = NULL; QString MAC, nick; char buff[300]; /* no deberia tener mas que esto cada linea */ int c = 0, p = 0; bool success = true; /* pre */ ASSERT (fname != NULL); memset (buff, '\0', 300); /* abrimos el archivo */ fd = fopen (fname, "r"); if (fd == NULL) { /* error */ debugp ("UDataBase::loadFromFile: error al abrir el archivo\n"); return false; } /* ahora leemos linea por linea y vamos generando usuarios y * metiendolos a la lista si es que existen */ c = fgetc(fd); while ((c != EOF) && success) { buff[p] = (char) c; if (c == ',') { /* entonces ya leimos el MAC antes */ buff[p] = '\0'; p = 0; /* reinicializamos el puntero */ MAC = QString (buff); /* guardamos el MAC */ } else if (c == '\n') { /* estamos en el caso en el que tenemos el nick antes */ buff[p] = '\0'; nick = QString (buff); /* agregamos el usuario si se puede, si no limpiamos * los strings */ success = udb_add_user (&MAC, &nick); /* reseteamos el puntero */ p = 0; } else p++; /* leemos el proximo caracteer */ c = fgetc(fd); /* hacemos un mini chequeo */ if (p == 300) success = false; } /* cerramos el archivo */ fclose (fd); return success; }
static int fill_hashtable(struct elf_htable *htable, struct kernel_symbol *start, struct kernel_symbol *stop, long s_offset) { struct kernel_symbol *ksym; uint32_t nb; unsigned long hvalue; int last_chain_slot; /* sanity check */ if ((htable->elf_buckets == NULL) || (htable->chains == NULL)) return -1; /* Initialize buckets and chains with -1 that means empty */ memset(htable->elf_buckets, -1, htable->nbucket * sizeof(uint32_t)); memset(htable->chains, -1, htable->nchain * sizeof(uint32_t)); nb = htable->nbucket; for (ksym = start, hvalue = 0; ksym < stop; ksym++, hvalue++) { const unsigned char *name = GET_KSTRING(ksym, s_offset); unsigned long h = gnu_hash(name); unsigned long idx = h % nb; uint32_t *slot = &htable->elf_buckets[idx]; /* * Store the index of the export symbol ksym in its * related __ksymtable in the hash table buckets for * using during lookup. * If the slot is alredy used ( != -1) then we have a collision * it needs to create an entry in the chain */ if (*slot == EMPTY_SLOT) *slot = hvalue; else { if (handle_collision(htable, *slot, hvalue) < 0) /* Something wrong happened */ return -1; } } /* * Update the chain lenght with the best value * so that we will cut unused entries beyond this upper limit * In the best case, when there are not collisions, htable->chains * will be 0 size... good ! */ /* Look for upper chains empty slot */ for (last_chain_slot = htable->nchain; --last_chain_slot >= 0 && htable->chains[last_chain_slot] == EMPTY_SLOT;); htable->nchain = last_chain_slot + 1; debugp("\t> Shortest chain lenght = %d\n", htable->nchain); return 0; }
void play( void *output_samples, uint32_t num_bytes ) { ao_play( dev, output_samples, num_bytes ); return; pthread_mutex_lock( &bufmutex ); memcpy( output_buffer, output_samples, num_bytes ); bytes_in_buffer = num_bytes; buffer_ready = 1; // Send signal debugp( DEBUGP_DEFAULT, 7, "signaling\n" ); pthread_cond_signal( &buftrig ); pthread_mutex_unlock( &bufmutex ); pthread_mutex_lock( &bufmutex ); pthread_cond_wait( &buftrig, &bufmutex ); pthread_mutex_unlock( &bufmutex ); return; }
//*---------------------------------------------------------------------------- //* \fn AT91F_DBGU_Init //* \brief This function is used to send a string through the DBGU channel (Very low level debugging) //*---------------------------------------------------------------------------- void AT91F_DBGU_Init(void) { unsigned int rst_status = AT91F_RSTGetStatus(AT91C_BASE_RSTC); dbgu_rb_init(); //* Open PIO for DBGU AT91F_DBGU_CfgPIO(); //* Enable Transmitter & receivier ((AT91PS_USART) AT91C_BASE_DBGU)->US_CR = AT91C_US_RSTTX | AT91C_US_RSTRX; //* Configure DBGU AT91F_US_Configure((AT91PS_USART) AT91C_BASE_DBGU, // DBGU base address MCK, AT91C_US_ASYNC_MODE, // Mode Register to be programmed AT91C_DBGU_BAUD, // Baudrate to be programmed 0); // Timeguard to be programmed //* Enable Transmitter & receivier ((AT91PS_USART) AT91C_BASE_DBGU)->US_CR = AT91C_US_RXEN | AT91C_US_TXEN; //* Enable USART IT error and AT91C_US_ENDRX AT91F_US_EnableIt((AT91PS_USART) AT91C_BASE_DBGU, AT91C_US_RXRDY); //* open interrupt sysirq_register(AT91SAM7_SYSIRQ_DBGU, &DBGU_irq_handler); AT91F_DBGU_Printk("\n\r"); AT91F_DBGU_Printk("(C) 2006-2011 by Harald Welte <*****@*****.**>\n\r" "This software is FREE SOFTWARE licensed under GNU GPL\n\r"); AT91F_DBGU_Printk("Version " COMPILE_SVNREV " compiled " COMPILE_DATE " by " COMPILE_BY "\n\r\n\r"); AT91F_DBGU_Printk("\n\rDEBUG Interface:\n\r" "0) Set Pull-up 1) Clear Pull-up 2) Toggle LED1 3) " "Toggle LED2\r\n9) Reset\n\r"); debugp("RSTC_SR=0x%08x\n", rst_status); }
/* Guarda en el archivo abierto al principio de todo, esto para * evitar inconsistencias de usuarios, tener repetidos y esas * cosas. */ void UDataBase::saveToFile (void) { QHash<QString, CUser*>::const_iterator i; QString data; CUser * user = NULL; /* reabrimos el archivo para escribirlo de cero y no hacerle appends */ if (this->file != NULL) fclose (this->file); this->file = fopen (qstrtochar(this->fname), "w"); /* verificamos que el archivo este abierto */ if (this->file == NULL){ debugp ("UDataBase::saveToFile: error file == NULL\n"); return; } /* iteramos sobre toda la hashtable */ for (i = this->hashTable.constBegin(); i != this->hashTable.constEnd(); ++i) { /* obtenemos el user */ user = i.value(); data = user->getMAC(); /* tenemos: MAC */ data.append(QChar(',')); /* tenemos: MAC, */ data.append (user->getNick()); /* tenemos: MAC,Nickname */ data.append(QChar('\n')); /* tenemos: MAC,Nickname\n */ /* ahora lo guardamos en el archivo */ fprintf (this->file, "%s", qstrtochar(data)); } fclose(this->file); }
static void add_elf_hashtable(struct buffer *b, const char *table, struct kernel_symbol *kstart, struct kernel_symbol *kstop, long off) { struct elf_htable htable = { .nbucket = 0, .nchain = 0, .elf_buckets = NULL, .chains = NULL, }; unsigned long nsyms = (unsigned long)(kstop - kstart); unsigned long i; htable.nbucket = compute_bucket_count(nsyms, 0); htable.elf_buckets = (uint32_t *) malloc(htable.nbucket * sizeof(uint32_t)); if (!htable.elf_buckets) return; /* * Worst case: the chain is as long as the maximum number of * exported symbols should be put in the chain */ htable.nchain = nsyms; htable.chains = (uint32_t *)malloc(htable.nchain * sizeof(uint32_t)); if (!htable.chains) return; debugp("\t> # buckets for %lu syms = %u\n", nsyms, htable.nbucket); if (fill_hashtable(&htable, kstart, kstop, off) < 0) return; buf_printf(b, "#ifdef CONFIG_LKM_ELF_HASH\n\n"); buf_printf(b, "#include <linux/types.h>\n"); buf_printf(b, "static uint32_t htable%s[]\n", table); buf_printf(b, "__attribute_used__\n"); buf_printf(b, "__attribute__((section(\"%s.htable\"))) = {\n", table); /* 1st entry is nbucket */ buf_printf(b, "\t%u, /* bucket lenght*/\n", htable.nbucket); /* 2nd entry is nchain */ buf_printf(b, "\t%u, /* chain lenght */\n", htable.nchain); buf_printf(b, "\t/* the buckets */\n\t"); for (i = 0; i < htable.nbucket; i++) buf_printf(b, "%d, ", htable.elf_buckets[i]); buf_printf(b, "\n\t/* the chains */\n\t"); for (i = 0; i < htable.nchain; i++) buf_printf(b, "%d, ", htable.chains[i]); buf_printf(b, "\n};\n"); buf_printf(b, "#endif\n"); free(htable.elf_buckets); free(htable.chains); } /** * Add hash table (old style) for exported symbols **/ /* FIXME: check on 64 bits host machine */ #define KSYMTABS (sizeof ksects / sizeof(ksects[0])) void add_ksymtable_hash(struct buffer *b, struct module *mod) { struct kernel_symbol *kstart, *kstop; unsigned int s; struct export_sect ksects[] = { { .name = "__ksymtab", .sec = mod->info->export_sec }, { .name = "__ksymtab_unused", .sec = mod->info->export_unused_sec }, { .name = "__ksymtab_gpl", .sec = mod->info->export_gpl_sec },
/* Funcion que Carga todas las variables de configuracion */ void TxtWinControl::loadConfigs(void) { ConfigManipulator * cm = NULL; QString var = ""; QString * value = NULL; QColor color; bool noError = true; int aux = 0; uint uaux = 0; /* verificamos que tw != NULL */ if (this->tw == NULL) { debugp ("TxtWinControl::loadConfigs: tw NULL\n"); return; } /* creamos el config manipulator */ cm = new ConfigManipulator (this->configName); /* cargamos la fuente y todo lo nescesario */ { QString * font = NULL, * pixSize = NULL, * pointSize = NULL; int poSize = -1, piSize = -1; QFont auxFont; var = "TXT_FONT"; font = cm->getValue (var); if (font == NULL) font = new QString (""); var = "TXT_FONT_POINT_SIZE"; pointSize = cm->getValue (var); if (pointSize != NULL) { poSize = pointSize->toInt (&noError); if (!noError) poSize = -1; delete pointSize; } var = "TXT_FONT_PIXEL_SIZE"; pixSize = cm->getValue (var); if (pixSize != NULL) { piSize = pixSize->toInt (&noError); if (!noError) piSize = -1; delete pixSize; } /* ahora cargamos la fuente */ auxFont = QFont::QFont(*font, poSize, piSize); this->tw->setTextFont (auxFont); delete font; } var = "TXT_FONT_COLOR"; value = cm->getValue (var); if (value != NULL) { uaux = value->toUInt (&noError); color = QColor::QColor (uaux); this->tw->setFontColor (color); delete value; value = NULL; } var = "TXT_BACK_COLOR"; value = cm->getValue (var); if (value != NULL) { uaux = value->toUInt (&noError); color = QColor::QColor (uaux); this->tw->setBackColor (color); delete value; value = NULL; } var = "TXT_WIN_POSITION_X"; value = cm->getValue (var); if (value != NULL) { aux = value->toInt (&noError); this->tw->move (aux, 0); delete value; value = NULL; } var = "TXT_WIN_POSITION_Y"; value = cm->getValue (var); if (value != NULL) { aux = value->toInt (&noError); this->tw->move (this->tw->pos().x(), aux); delete value; value = NULL; } var = "TXT_WIN_SIZE_X"; value = cm->getValue (var); if (value != NULL) { aux = value->toInt (&noError); this->tw->resize (aux, 0); delete value; value = NULL; } var = "TXT_WIN_SIZE_Y"; value = cm->getValue (var); if (value != NULL) { aux = value->toInt (&noError); this->tw->resize (this->tw->size().width(), aux); delete value; value = NULL; } var = "TXT_WIN_STYLE"; value = cm->getValue (var); if (value != NULL) { Qt::WindowFlags flags = 0; flags = (Qt::WindowFlags) value->toUInt (&noError); this->tw->setWindowFlags (flags); delete value; value = NULL; } var = "TXT_VELOCITY1"; value = cm->getValue (var); if (value != NULL) { aux = value->toInt (&noError); this->tw->setVelocity (aux); this->scrollVel1->setValue(aux); delete value; value = NULL; } var = "TXT_VELOCITY2"; value = cm->getValue (var); if (value != NULL) { aux = value->toInt (&noError); this->tw->setStep (aux); this->scrollVel2->setValue(aux); delete value; value = NULL; } var = "TXT_BETWEN"; value = cm->getValue (var); if (value != NULL) { this->tw->setBetween (*value); delete value; value = NULL; } delete cm; }
/* Funcion que guarda todas las variables de configuracion */ void TxtWinControl::saveConfigs(void) { ConfigManipulator * cm = NULL; QString var = ""; QString value = ""; /* verificamos que tw != NULL */ if (this->tw == NULL) { debugp ("TxtWinControl::saveConfigs: tw NULL\n"); return; } /* creamos el config manipulator */ cm = new ConfigManipulator (this->configName); /* ahora vamos a configurar todo */ var = "TXT_FONT"; value = (this->tw->font()).family(); cm->setValue (var, value); var = "TXT_FONT_PIXEL_SIZE"; value.setNum((this->tw->font()).pixelSize()); cm->setValue (var, value); var = "TXT_FONT_POINT_SIZE"; value.setNum((this->tw->font()).pointSize()); cm->setValue (var, value); var = "TXT_FONT_COLOR"; value.setNum (this->tw->getFontColor().rgb()); cm->setValue (var, value); var = "TXT_BACK_COLOR"; value.setNum (this->tw->palette().color (QPalette::Background).rgb()); cm->setValue (var, value); var = "TXT_WIN_POSITION_X"; value.setNum((this->tw->pos()).x()); cm->setValue (var, value); var = "TXT_WIN_POSITION_Y"; value.setNum((this->tw->pos()).y()); cm->setValue (var, value); var = "TXT_WIN_SIZE_X"; value.setNum((this->tw->size()).width()); cm->setValue (var, value); var = "TXT_WIN_SIZE_Y"; value.setNum((this->tw->size()).height()); cm->setValue (var, value); var = "TXT_WIN_STYLE"; value.setNum(this->tw->windowFlags()); cm->setValue (var, value); var = "TXT_VELOCITY1"; value.setNum(this->tw->getVelocity()); cm->setValue (var, value); var = "TXT_VELOCITY2"; value.setNum(this->tw->getStep()); cm->setValue (var, value); var = "TXT_BETWEN"; value = this->tw->getBetween(); cm->setValue (var, value); /* guardamos y salimos */ cm->saveChanges(); delete cm; }
int optimize(void) { int retval = 0; FILE *fp; set_debug_level(0); if( num_phash_queries <= 0 ) { debugp( 0, "Specify a query!\n" ); return 3; } if( logfile_name != NULL ) { fp = fopen( logfile_name, "a" ); if( fp == NULL ) return 1; } else return 2; char buffer[1024]; sprintf( buffer, "======================================== %3d ITERATIONS PER TEST ========================================\n", optimize_iterations ); //fwrite( buffer, sizeof(char), strlen(buffer), fp ); //start_timer(); init_database(); load_phashes(); // into master_list /* master_list gets depleated; make a copy */ struct phash_list master_backup; master_backup.count = master_list.count; master_backup.hashes = (unsigned long long*)malloc(sizeof(unsigned long long) * master_backup.count); memcpy(master_backup.hashes,master_list.hashes,sizeof(unsigned long long) * master_backup.count); deinit_database(); unsigned long long phash = phash_queries[0]; //for( int dist=query_max_distance/2; dist<=query_max_distance*1.5; dist++ ) for( int dist=8; dist == 8; dist ++ ) { int nodesize; for( nodesize = 5; nodesize<= 10000; nodesize+=10 ) { double total_saved = 0; double total_query_time = 0; //unsigned long total_matches = 0; int test = 0; hd_count = 0; max_leaf_distance = nodesize; query_max_distance = dist; if( master_list.hashes == NULL ) { /* copy backup back into master_list */ master_list.count = master_backup.count; master_list.hashes = (unsigned long long*)malloc(sizeof(unsigned long long) * master_backup.count); memcpy(master_list.hashes,master_backup.hashes,sizeof(unsigned long long) * master_backup.count); } double indexing_time = 0, query_time = 0; start_timer(); set_debug_level(4); unsigned long long seed = get_best_seed( &master_list, 0 ); master_tree = index_phashes(master_tree,&master_list,NULL,seed,0); indexing_time = stop_timer(); set_debug_level(0); debugp( 0, "Querying for 0x%llX with maximum hamming distance of %d, nodesize = %d\n", phash, query_max_distance, max_leaf_distance ); struct pmatches *mymatches = NULL; long qcount = 0; for( test=0; test<optimize_iterations; test++ ) { mymatches = NULL; start_timer(); if( flag_pthread_test ) mymatches = query_phash2( master_tree, phash, query_max_distance, mymatches ); else mymatches = query_phash( master_tree, phash, query_max_distance, mymatches ); query_time = stop_timer(); total_query_time += query_time; qcount += mymatches->count; free(mymatches); } double mean_query_time = total_query_time / ((double)test+1.0); int phash_count = count_all_phashes(0,master_tree); double saved = (double)(phash_count - comparison_count) / phash_count * 100.0; total_saved += saved; debugp( 0, "\n======= EFFICIENCY SUMMARY =======\n" ); debugp( 0, "Indexing Time: %15.8f\n", indexing_time ); //debugp( 0, "HD Count: %15lu\n", hd_count ); debugp( 0, "P-Hash Count: %15d\n", phash_count ); debugp( 0, "Node Count: %15d\n", node_count ); debugp( 0, "Query Time: %15.8f\n", mean_query_time ); debugp( 0, "Result Count: %15.8f\n", qcount / ((double)test+1.0)); debugp( 0, "\n" ); /* Cleanup */ node_count = 0; load_time = 0; comparison_count = 0; free_vp_tree(master_tree); master_tree = NULL; master_list.count = 0; master_list.hashes = NULL; sprintf( buffer, "%2d,%2d,%7.6f\n", nodesize, dist, mean_query_time ); fwrite( buffer, sizeof(char), strlen(buffer), fp ); fflush(fp); } } fclose(fp); return retval; }
void parse_args( int argc, char *argv[] ) { struct option long_options[] = { { "thread-test", no_argument, &flag_pthread_test, 1 }, { "threads", required_argument, NULL, 't' }, { "traverse-all", no_argument, &flag_traverse_all, 1 }, { "logfile", required_argument, NULL, 'l' }, { "iterations", required_argument, NULL, 0 }, { "optimize", optional_argument, NULL, 0 }, { "load-multiple-times", required_argument, NULL, 0 }, { "slow", required_argument, NULL, 0 }, { "efficiency-debug", optional_argument, NULL, 0 }, { "php", optional_argument, &flag_php, 1 }, { "query", required_argument, NULL, 'q' }, { "query-distance", required_argument, NULL, 'd' }, { "max-leaf-distance", required_argument, NULL, 0 }, { "syslog", optional_argument, NULL, 0 }, { "verbose", optional_argument, NULL, 'v' }, { 0, 0, 0, 0 } }; int long_options_index; int c; while( ( c = getopt_long( argc, argv, "t:l:i:o:pd:vq:", long_options, &long_options_index )) != -1 ) { unsigned long long phash = 0; switch(c) { case 0: /* Long options with no short equivalent */ if( strcmp( long_options[long_options_index].name, "syslog" ) == 0 ) { debugp( 0, "Changing debug facility to syslog... goodbye!\n" ); setup_debugp_syslog( "productometer" ); change_debug_facility( DEBUGP_SYSLOG ); debugp( 4, "changed debug facility to syslog\n" ); } else if( strcmp( long_options[long_options_index].name, "efficiency-debug" ) == 0 ) { flag_efficiency_debug = 1; } else if( strcmp( long_options[long_options_index].name, "slow" ) == 0 ) { sscanf( optarg, "%ld", &flag_slow ); } else if( strcmp( long_options[long_options_index].name, "load-multiple-times" ) == 0 ) { flag_load_multiple_times = atoi(optarg); } else if( strcmp( long_options[long_options_index].name, "optimize" ) == 0 ) { function = optimization; } else if( strcmp( long_options[long_options_index].name, "iterations" ) == 0 ) { optimize_iterations = atoi(optarg); } break; case 't': num_pthreads = atoi(optarg); break; case 'o': output_file = optarg; break; case 'i': input_file = optarg; break; case 'p': flag_print_vp_tree = 1; break; case 'v': change_debug_level_by(1); break; case 'q': if( sscanf( optarg, "%llx", &phash ) == 1 ) { num_phash_queries++; phash_queries = (unsigned long long*)realloc(phash_queries,sizeof(unsigned long long) * num_phash_queries); phash_queries[num_phash_queries-1] = phash; debugp( 2, "Adding phash query value 0x%llX\n", phash ); } else { debugp( 0, "Error parsing query: `%s'\n", optarg ); } break; case 'd': query_max_distance = atoi(optarg); debugp( 2, "Query maximum hamming distance set to %d\n", query_max_distance ); break; case 'l': logfile_name = optarg; break; default: break; } } return; }
int command_line_function(void) { int retval = 0; start_timer(); if( flag_efficiency_debug ) efficiency_init(); if( input_file == NULL ) { init_database(); load_phashes(); for( int f=0; f < flag_load_multiple_times; f++ ) load_phashes(); unsigned long long seed = 0x3333CCCCCCCC3333; master_tree = index_phashes(master_tree,&master_list,NULL,seed,0); } else { master_tree = load_index(input_file); } load_time = stop_timer(); double total_query_time = 0; if( num_pthreads > num_phash_queries ) num_pthreads = num_phash_queries; struct threaded_query_pkg *packages[num_phash_queries]; pthread_t threads[num_pthreads]; int threads_running = 0; int q = num_phash_queries; pthread_t *current_thread = threads; int query_num = 1; int join_count = 0; while(q--) { packages[q] = (struct threaded_query_pkg*)malloc(sizeof(struct threaded_query_pkg)); packages[q]->done = 0; packages[q]->query_num = query_num; packages[q]->query = phash_queries[q]; debugp( 3, "Launching thread #%d (%d running)\n", q, threads_running ); pthread_create( &(*current_thread), NULL, &threaded_query, (void*)packages[q] ); query_num++; threads_running++; current_thread++; if( (current_thread - threads) >= num_pthreads ) { current_thread = threads; } if( threads_running >= num_pthreads ) { pthread_join( *current_thread, NULL ); join_count++; threads_running--; } } for( int t = 0; t < num_pthreads; t++ ) { pthread_join( threads[t], NULL ); } for( q=0; q < num_phash_queries; q++ ) { total_query_time += packages[q]->query_time; debugp( 1, "Query #%d: phash = 0x%llX d <= %d] (%f sec) \n", q+1, packages[q]->query, query_max_distance, packages[q]->query_time ); debugp( 2, "packages[%d]->matches is at %p\n", q, packages[q]->matches ); if(packages[q]->matches != NULL) debugp( 2, "packages[%d]->matches->count = %d\n", q, packages[q]->matches->count ); if( (packages[q]->matches != NULL) && (packages[q]->matches->count) ) { for( int m=0; m < packages[q]->matches->count; m++ ) { debugp( 1, " Match #%d: 0x%llX (d=%d)\n", m+1, packages[q]->matches->matches[m].phash, packages[q]->matches->matches[m].dist ); if( flag_php ) { printf( "%llX\n", packages[q]->matches->matches[m].phash ); } } } else { debugp( 1, " ** No Matches **\n" ); } debugp( 2, "packages[%d]->done = %d\n", q, packages[q]->done ); if(packages[q]->matches != NULL) free(packages[q]->matches->matches); free(packages[q]->matches); free(packages[q]); } double avg_query_time = total_query_time / (double)num_phash_queries; if( logfile_name != NULL ) { FILE *fp; if( (fp = fopen( logfile_name, "a" )) ) { char buffer[512]; sprintf( buffer, "%d,%f,%f\n", num_phash_queries,avg_query_time,total_query_time ); fwrite( buffer, sizeof(char), strlen(buffer), fp ); } fclose(fp); } if( input_file == NULL ) deinit_database(); if( flag_print_vp_tree ) { print_vp_tree(master_tree); size_t size = get_recursive_node_size(master_tree); debugp( 1, "Total size: %d bytes\n", size ); } if( output_file != NULL ) save_index( master_tree, output_file ); if( flag_efficiency_debug ) print_efficiency_summary(); free_vp_tree(master_tree); return retval; }