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;
}
