int do_files_differ(
const char* filename1,
const char* filename2,
bool* result_out
)
{
if(!filename1 || !filename2 || !result_out)
{
return -1;
}
size_t file1size = 0;
size_t file2size = 0;
if(get_filesize(filename1, &file1size) || get_filesize(filename2, &file2size))
{
return -1;
}
if(file1size == file2size)
{
uint8_t* buffer1 = calloc(file1size, 1);
uint8_t* buffer2 = calloc(file2size, 1);
if(read_file_into_buffer(filename1, buffer1, file1size))
{
free(buffer1);
free(buffer2);
return -1;
}
if(read_file_into_buffer(filename2, buffer2, file2size))
{
free(buffer1);
free(buffer2);
return -1;
}
*result_out = (memcmp(buffer1, buffer2, file1size) != 0);
free(buffer1);
free(buffer2);
return 0;
}
else
{
*result_out = true;
return 0;
}
// Should not reach here
return -1;
}
int main(void) {
char* buffer = read_file_into_buffer(FILEPATH);
cuckoo_hash_table* ht = cuckoo_mult_init(6, 25);
load_words_into_hashtable(ht, buffer, strlen(buffer));
cuckoo_mult_print_table(ht);
return 0;
}
int SOMAexternal (SOMAsetup *ssetup, FitnessFunction ffunc, int nparams, Parameter *params, const char *file, SOMAreturn* sr) {
Array2D array;
char *buf;
long len;
struct csv_parser csvp;
clock_t begin, end;
array_init (&array);
array_append_column(&array); //blank column for external fitness function
array.currentcolumn++;
//Parse CSV file
if (csv_init (&csvp, CSV_APPEND_NULL)!=0)
return ERR;
if ((buf=read_file_into_buffer (file, &len))==NULL)
return ERR_FILE;
csv_parse (&csvp, buf, len, csvcallback1, csvcallback2e, (void*) &array);
csv_fini (&csvp, csvcallback1, csvcallback2e, (void*) &array);
csv_free (&csvp);
//array_print (&array); //debug
//soma_array=&array;
//Initialize output struct
SOMAreturn_init (sr, ssetup->Migrations, nparams);
begin=clock();
//SOMA call
SOMA2 (ssetup, nparams, params, sr, &array, ffunc);
end=clock();
sr->time=(double) (end-begin)/CLOCKS_PER_SEC;
array_delete (&array);
return OK;
}
int SOMAascii (SOMAsetup *ssetup, const char *expr, int nparams, Parameter *params, const char *file, SOMAreturn* sr) {
Array2D array;
int i;
char *buf;
long len;
struct csv_parser csvp;
clock_t begin, end;
MuExpr me;
array_init(&array);
//Parse CSV file
if (csv_init (&csvp, CSV_APPEND_NULL)!=0)
return ERR;
if ((buf=read_file_into_buffer (file, &len))==NULL)
return ERR_FILE;
csv_parse (&csvp, buf, len, csvcallback1, csvcallback2, (void*) &array);
csv_fini (&csvp, csvcallback1, csvcallback2, (void*) &array);
csv_free (&csvp);
//array_print (&array); //debug
muexpr_init (&me, expr);
for (i=0; i<nparams; i++)
if (defpar (&me, params+i, i)!=OK) {
return ERR_PARAMS;
array_delete (&array);
muexpr_free (&me);
}
findvars (&me, VAR_NAME_PREFIX);
//CVS file and expression don't match
if (me.nvars!=array.ncolumns-1) {
array_delete (&array);
muexpr_free (&me);
return ERR_COLUMNS;
}
muexpr_eval (&me);
if (mupError (me.hparser)) {
array_delete (&array);
muexpr_free (&me);
return ERR_EXPR;
}
//Initialize output struct
SOMAreturn_init (sr, ssetup->Migrations, nparams);
begin=clock();
//SOMA call
SOMA (ssetup, nparams, params, sr, &array, &me);
end=clock();
sr->time=(double) (end-begin)/CLOCKS_PER_SEC;
array_delete (&array);
muexpr_free (&me);
return OK;
}
int main (int argc, char **argv)
{
int i;
int tmp;
struct list_element_t *temp_element_p;
int opt;
process_name = argv[0];
pthread_mutex_init(&list_mtx, NULL);
pthread_mutex_init(&data_ready_mtx, NULL);
pthread_cond_init(&data_ready_cv, NULL);
pthread_t thread_refs[MAX_NUM_PROCS];
//get command line options
while ((opt = getopt(argc, argv, "hP:c:f:eQ:R:")) != -1)
{
switch (opt)
{
case 'c':
command = optarg;
break;
case 'e':
ensure_exit = 1;
break;
case 'f':
if ( read_file_into_buffer(optarg,&command) == 0)
{
exit(2);
}
break;
case 'P':
num_procs = atoi(optarg);
if (num_procs > MAX_NUM_PROCS) num_procs = MAX_NUM_PROCS;
break;
case 'R':
consumer_bottleneck_poll_interval = atoi(optarg);
break;
case 'Q':
list_elements_per_proc = atoi(optarg);
break;
default:
print_usage();
fprintf(stderr,"Invalid option %c\n", opt);
exit(2);
break;
}
}
//too many args or too few
if (argc > optind || argc < 2)
{
print_usage();
fprintf(stderr,"Invalid command line options\n");
}
//make sure there is a command to run
if ( command == NULL )
{
fprintf(stderr, "You must specify a command to run\n");
print_usage();
exit(2);
}
if (consumer_bottleneck_poll_interval < 0)
{
print_usage();
fprintf(stderr,"Invalid Wait Period\n");
exit(2);
}
if (list_elements_per_proc < 1)
{
print_usage();
fprintf(stderr,"Invalid line buffer size\n");
exit(2);
}
if (num_procs < 1)
{
print_usage();
fprintf(stderr,"Invalid number of processes\n");
exit(2);
}
num_list_elements = num_procs * list_elements_per_proc;
//intialize the list elements and lists
for (i = 0; i < num_list_elements; i++)
{
//malloc each element and set link
temp_element_p = (struct list_element_t *) malloc(sizeof(struct list_element_t));
if (temp_element_p == NULL)
{
fprintf(stderr, "Malloc failed.\n");
exit(2);
}
list_add(&free_list, temp_element_p);
}
//now start up the threads.
for (i=0; i < num_procs; i++)
{
tmp = pthread_create(&thread_refs[i], NULL, writer_thread, NULL);
if (tmp != 0 )
{
fprintf(stderr, "pthread create failed for proc %i with return value of: %i.\n", i, tmp);
exit(2);
}
}
grablock();
temp_element_p = list_remove(&free_list);
releaselock();
//loop through each line of input
while(fgets(temp_element_p->buffer, PATH_MAX, stdin) != NULL)
{
grablock();
list_add(&ready_list, temp_element_p);
temp_element_p = list_remove(&free_list);
releaselock();
signal_data_ready();
//if we are backed up, signal again
if (list_length(&free_list) < (num_list_elements/2))
{
broadcast_data_ready();
}
//wait if we don't have any free list elements available, keep signalling all the while
while (temp_element_p == NULL)
{
usleep(consumer_bottleneck_poll_interval);
broadcast_data_ready();
grablock();
temp_element_p = list_remove(&free_list);
releaselock();
}
}
//wait for ready_list to empty
while(list_length(&ready_list) > 0)
{
signal_data_ready();
}
input_done = 1;
//make sure no one is stuck on condition variable
broadcast_data_ready();
//fprintf(stderr, "Done processing input, finishing up\n");
//join all the writer threads
for (i = 0; i < num_procs; i++)
{
pthread_join(thread_refs[i], NULL);
}
exit(0);
}
