static void
destroy_cb (GtkObject *object,
ChangeDisplayInfo **info)
{
destroy_info (*info);
*info = NULL;
}
int rsvp_dataref_thread_close_reference(const struct dataref_source_info *iInfo, int rReference)
{
if (!message_queue_status() || !iInfo) return -1;
if (iInfo->respond) return 1;
pthread_t new_thread = (pthread_t) NULL;
copied_info *current_info = NULL;
if ( pthread_create( &new_thread, NULL, &thread_close_reference,
static_cast <copied_info*> (current_info = duplicate_info(iInfo, NULL, rReference, 0x00, 0x00, 0, 0)) ) != 0)
{
destroy_info(current_info);
return -1;
}
else return 0;
}
int rsvp_dataref_thread_transfer_data(const struct dataref_source_info *iInfo, int rReference,
uint8_t mMode, ssize_t oOffset, ssize_t sSize)
{
if (!message_queue_status() || !iInfo) return -1;
if (iInfo->respond) return 1;
pthread_t new_thread = (pthread_t) NULL;
copied_info *current_info = NULL;
if ( pthread_create( &new_thread, NULL, &thread_transfer_data,
static_cast <copied_info*> (current_info = duplicate_info(iInfo, NULL, rReference, 0x00, mMode, oOffset, sSize)) ) != 0)
{
destroy_info(current_info);
return -1;
}
else return 0;
}
int rsvp_dataref_thread_open_reference(const struct dataref_source_info *iInfo, text_info lLocation,
int rReference, uint8_t tType, uint8_t mMode)
{
if (!message_queue_status() || !iInfo) return -1;
if (iInfo->respond) return 1;
pthread_t new_thread = (pthread_t) NULL;
copied_info *current_info = NULL;
if ( pthread_create( &new_thread, NULL, &thread_open_reference,
static_cast <copied_info*> (current_info = duplicate_info(iInfo, lLocation, rReference, tType, mMode, 0, 0)) ) != 0)
{
destroy_info(current_info);
return -1;
}
else return 0;
}
static void *thread_alteration(void *cCopy)
{
if (!cCopy) return NULL;
copied_info *const current_info = static_cast <copied_info*> (cCopy);
command_event outcome = __rsvp_dataref_hook_alteration(¤t_info->info,
current_info->reference, current_info->offset, current_info->size);
if (current_info->info.respond && outcome != event_none)
{
command_handle new_response = short_response(current_info->info.respond, outcome);
if (new_response) send_command_no_status(new_response);
destroy_command(new_response);
}
destroy_info(current_info);
return NULL;
}
int
main(int argc, char *argv[])
{
size_t path_len, total_files;
off_t bytes_wasted, total_wasted;
char path_buffer[PATH_MAX_LEN], *hash_value;
struct file_entry_t *file_entry, *trie_entry;
SListIterator slist_iterator;
SetIterator set_iterator;
/* Step 0: Session data */
struct file_info_t file_info;
clear_info(&file_info);
/* Step 1: Parse arguments */
while (--argc) {
/* Being unable to record implies insufficient resources */
if (!record(argv[argc], &file_info)){
fprintf(stderr, "[FATAL] out of memory\n");
destroy_info(&file_info);
return (EXIT_FAILURE);
}
}
/* Step 2: Fully explore any directories specified */
#ifndef NDEBUG
printf("[DEBUG] Creating file list...\n");
#endif
while (slist_length(file_info.file_stack) > 0) {
/* Pick off the top of the file stack */
file_entry = (struct file_entry_t *)(slist_data(file_info.file_stack));
slist_remove_entry(&file_info.file_stack, file_info.file_stack);
assert(file_entry->type == DIRECTORY);
/* Copy the basename to a buffer */
memset(path_buffer, '\0', PATH_MAX_LEN);
path_len = strnlen(file_entry->path, PATH_MAX_LEN);
memcpy(path_buffer, file_entry->path, path_len);
/* Ignore cases that would cause overflow */
if (path_len < PATH_MAX_LEN) {
/* Append a trailing slash */
path_buffer[path_len] = '/';
/* Record all contents (may push onto file stack or one of the lists) */
DIR *directory = opendir(file_entry->path);
if (traverse(&file_info, directory, path_buffer, ++path_len)) {
fprintf(stderr, "[FATAL] out of memory\n");
destroy_info(&file_info);
return (EXIT_FAILURE);
} else if (closedir(directory)) {
fprintf(stderr, "[WARNING] '%s' (close failed)\n", file_entry->path);
}
}
/* Discard this entry */
destroy_entry(file_entry);
}
/* Step 3: Warn about any ignored files */
if (slist_length(file_info.bad_files) > 0) {
slist_iterate(&file_info.bad_files, &slist_iterator);
while (slist_iter_has_more(&slist_iterator)) {
file_entry = slist_iter_next(&slist_iterator);
fprintf(stderr, "[WARNING] '%s' ", file_entry->path);
switch (file_entry->type) {
case INVALID:
++file_info.invalid_files;
fprintf(stderr, "(invalid file)\n");
break;
case INACCESSIBLE:
++file_info.protected_files;
fprintf(stderr, "(protected file)\n");
break;
default:
++file_info.irregular_files;
fprintf(stderr, "(irregular file)\n");
break;
}
}
fprintf(stderr, "[WARNING] %lu file(s) ignored\n",
(long unsigned)(num_errors(&file_info)));
}
#ifndef NDEBUG
if (num_errors(&file_info) > 0) {
fprintf(stderr, "[FATAL] cannot parse entire file tree\n");
destroy_info(&file_info);
return (EXIT_FAILURE);
}
printf("[DEBUG] Found %lu / %lu valid files\n",
(unsigned long)(num_files(&file_info)),
(unsigned long)(file_info.total_files));
#endif
/* Step 4: Begin the filtering process */
#ifndef NDEBUG
printf("[DEBUG] Creating file table...\n");
#endif
if (slist_length(file_info.good_files) > 0) {
file_info.hash_trie = trie_new();
file_info.shash_trie = trie_new();
optimize_filter(&file_info);
/* Extract each file from the list (they should all be regular) */
slist_iterate(&file_info.good_files, &slist_iterator);
while (slist_iter_has_more(&slist_iterator)) {
file_entry = slist_iter_next(&slist_iterator);
assert(file_entry->type == REGULAR);
/* Perform a "shallow" hash of the file */
hash_value = hash_entry(file_entry, SHALLOW);
#ifndef NDEBUG
printf("[SHASH] %s\t*%s\n", file_entry->path, hash_value);
#endif
/* Check to see if we might have seen this file before */
if (bloom_filter_query(file_info.shash_filter, hash_value)) {
/* Get the full hash of the new file */
hash_value = hash_entry(file_entry, FULL);
#ifndef NDEBUG
printf("[+HASH] %s\t*%s\n", file_entry->path, hash_value);
#endif
archive(&file_info, file_entry);
/* Check to see if bloom failed us */
trie_entry = trie_lookup(file_info.shash_trie, file_entry->shash);
if (trie_entry == TRIE_NULL) {
#ifndef NDEBUG
printf("[DEBUG] '%s' (false positive)\n", file_entry->path);
#endif
trie_insert(file_info.shash_trie, file_entry->shash, file_entry);
} else {
/* Get the full hash of the old file */
hash_value = hash_entry(trie_entry, FULL);
#ifndef NDEBUG
if (hash_value) {
printf("[-HASH] %s\t*%s\n", trie_entry->path, hash_value);
}
#endif
archive(&file_info, trie_entry);
}
} else {
/* Add a record of this shash to the filter */
bloom_filter_insert(file_info.shash_filter, hash_value);
trie_insert(file_info.shash_trie, hash_value, file_entry);
}
}
persist("bloom_store", &file_info);
}
/* Step 5: Output results and cleanup before exit */
printf("[EXTRA] Found %lu sets of duplicates...\n",
(unsigned long)(slist_length(file_info.duplicates)));
slist_iterate(&file_info.duplicates, &slist_iterator);
for (total_files = total_wasted = bytes_wasted = 0;
slist_iter_has_more(&slist_iterator);
total_wasted += bytes_wasted)
{
Set *set = slist_iter_next(&slist_iterator);
int size = set_num_entries(set);
if (size < 2) { continue; }
printf("[EXTRA] %lu files (w/ same hash):\n", (unsigned long)(size));
set_iterate(set, &set_iterator);
for (bytes_wasted = 0;
set_iter_has_more(&set_iterator);
bytes_wasted += file_entry->size,
++total_files)
{
file_entry = set_iter_next(&set_iterator);
printf("\t%s (%lu bytes)\n",
file_entry->path,
(unsigned long)(file_entry->size));
}
}
printf("[EXTRA] %lu bytes in %lu files (wasted)\n",
(unsigned long)(total_wasted),
(unsigned long)(total_files));
destroy_info(&file_info);
return (EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
#if 1
if(0 == isArbiterExist())
{
marbit_send_log(ERROR,"arbiter is not start!\n");
exit(1);
}
#endif
//init sys info
if(0 != init_sys_info())
{
marbit_send_log(ERROR,"Failed to init_sys_info!\n");
exit(1);
}
//parse the parameters
if(0 != parse_input_parameters(argc, argv))
{
destroy_info();
input_error();
exit(1);
}
//time_t begin_time = time(NULL);
// time_t do_process_data_stream_time= time(NULL);
// time_t do_process_data_aggregation_time= time(NULL);
// time_t do_process_sort_time = time(NULL);
// time_t print_baselink_time = time(NULL);
//time_t print_sorted_list_time = time(NULL);
struct timeval start, getFromArbiter, printLink, dataAggregation, quickSort, printSort, end;
gettimeofday( &start, NULL );
#if 1
//data_stream, check need get data stream from arbiter or configure file
if(0 == isNeedReadFromDB(DATA_STREAM_FILE_PATH, g_flush_interval))
{
//set_timer();
if(0 != do_process_from_arbiter())
{
marbit_send_log(ERROR,"Failed to get data stream from arbiter\n");
exit(1);
}
}
gettimeofday( &getFromArbiter, NULL );
#endif
if(SORTED_BASE_LINK == g_sorted_list_index)
{
print_baselink_info(DATA_STREAM_FILE_PATH);
gettimeofday( &printLink, NULL );
}
else if(SORTED_BASE_APP == g_sorted_list_index || SORTED_BASE_IP == g_sorted_list_index)
{
//data_aggregation
do_process_data_aggregation();
gettimeofday( &dataAggregation, NULL );
#if 1
MergeSort(&merglist);
gettimeofday( &quickSort, NULL );
printMergeList(merglist);
gettimeofday( &printSort, NULL );
destroyMergelist(merglist);
#else
struct list_head *head = &sorted_list_arry[SORTED_BASE_AGG].list;
//struct list_head *head = &sorted_list_arry[g_sorted_list_index].list;
struct list_head *first = head->next;
struct list_head *last = head->prev;
sorted_node_t *pstHead = list_entry(head, sorted_node_t, list);
quick_sort(head, first, last);
gettimeofday( &quickSort, NULL );
print_sorted_list(SORTED_BASE_AGG);
//print_sorted_list(g_sorted_list_index);
gettimeofday( &printSort, NULL );
#endif
}
destroy_info();
gettimeofday( &end, NULL );
if(logdebug.g_trace_enable_flag > 0)
{
marbit_send_log(INFO,"=======================================\n");
int timeuse = 0;
if(SORTED_BASE_LINK == g_sorted_list_index)
{
timeuse = 1000000 * ( end.tv_sec - start.tv_sec ) + end.tv_usec - start.tv_usec;
marbit_send_log(INFO,"all used time = %lu us\n", timeuse);
timeuse = 1000000 * ( getFromArbiter.tv_sec - start.tv_sec ) + getFromArbiter.tv_usec - start.tv_usec;
marbit_send_log(INFO,"getFromArbiter used time = %lu us\n", timeuse);
timeuse = 1000000 * ( printLink.tv_sec - getFromArbiter.tv_sec ) + printLink.tv_usec - getFromArbiter.tv_usec;
marbit_send_log(INFO,"printLink used time = %lu us\n", timeuse);
timeuse = 1000000 * ( end.tv_sec - printLink.tv_sec ) + end.tv_usec - printLink.tv_usec;
marbit_send_log(INFO,"destroy used time = %lu us\n", timeuse);
}
else
{
timeuse = 1000000 * ( end.tv_sec - start.tv_sec ) + end.tv_usec - start.tv_usec;
marbit_send_log(INFO,"all used time = %lu us\n", timeuse);
timeuse = 1000000 * ( getFromArbiter.tv_sec - start.tv_sec ) + getFromArbiter.tv_usec - start.tv_usec;
marbit_send_log(INFO,"getFromArbiter used time = %lu us\n", timeuse);
timeuse = 1000000 * ( dataAggregation.tv_sec - getFromArbiter.tv_sec ) + dataAggregation.tv_usec - getFromArbiter.tv_usec;
marbit_send_log(INFO,"dataAggregation used time = %lu us\n", timeuse);
timeuse = 1000000 * ( quickSort.tv_sec - dataAggregation.tv_sec ) + quickSort.tv_usec - dataAggregation.tv_usec;
marbit_send_log(INFO,"quickSort used time = %lu us\n", timeuse);
timeuse = 1000000 * ( printSort.tv_sec - quickSort.tv_sec ) + printSort.tv_usec - quickSort.tv_usec;
marbit_send_log(INFO,"printSort used time = %lu us\n", timeuse);
timeuse = 1000000 * ( end.tv_sec - printSort.tv_sec ) + end.tv_usec - printSort.tv_usec;
marbit_send_log(INFO,"destroy used time = %lu us\n", timeuse);
}
}
return 0;
}