/* This file is part of the Linux Trace Toolkit viewer
- * Copyright (C) 2009 Benjamin Poirier <benjamin.poirier@polymtl.ca>
+ * Copyright (C) 2009, 2010 Benjamin Poirier <benjamin.poirier@polymtl.ca>
*
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License Version 2 as
- * published by the Free Software Foundation;
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or (at
+ * your option) any later version.
*
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
*
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
- * MA 02111-1307, USA.
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#define _GNU_SOURCE
#include <sys/stat.h>
#include <unistd.h>
+#include "event_processing_text.h"
+#include "event_matching_tcp.h"
+#include "event_matching_broadcast.h"
+#include "event_matching_distributor.h"
+#include "event_analysis_chull.h"
+#include "event_analysis_linreg.h"
+#include "event_analysis_eval.h"
+#include "factor_reduction_accuracy.h"
#include "sync_chain.h"
{
GArray* longOptions;
GString* optionString;
- GQueue* index;
+ GQueue* longIndex;
+ GHashTable* shortIndex;
};
static void nullLog(const gchar *log_domain, GLogLevelFlags log_level, const
gchar *message, gpointer user_data);
static void gfAddModuleOption(gpointer data, gpointer user_data);
+static guint ghfCharHash(gconstpointer key);
+static gboolean gefCharEqual(gconstpointer a, gconstpointer b);
static ModuleOption optionSyncStats= {
.hasArg= REQUIRED_ARG,
.optionHelp= "Specify which algorithm to use for event analysis",
};
+static ModuleOption optionSyncReduction= {
+ .shortName= 'r',
+ .longName= "sync-reduction",
+ .hasArg= REQUIRED_ARG,
+ .optionHelp= "Specify which algorithm to use for factor reduction",
+};
/*
struct timeval startTime, endTime;
struct rusage startUsage, endUsage;
GList* result;
+ GArray* factors;
int retval;
bool stats;
const char* testCaseName;
GString* analysisModulesNames;
+ GString* reductionModulesNames;
+ unsigned int id;
+ AllFactors* allFactors;
+
+ /*
+ * Initialize event modules
+ * Call the "constructor" or initialization function of each event module
+ * so it can register itself. This must be done before elements in
+ * processingModules, matchingModules, analysisModules or moduleOptions
+ * are accessed.
+ */
+ registerProcessingText();
+
+ registerMatchingTCP();
+ registerMatchingBroadcast();
+ registerMatchingDistributor();
+
+ registerAnalysisCHull();
+ registerAnalysisLinReg();
+ registerAnalysisEval();
+
+ registerReductionAccuracy();
// Initialize data structures
syncState= malloc(sizeof(SyncState));
g_string_truncate(analysisModulesNames, analysisModulesNames->len - 2);
optionSyncAnalysis.argHelp= analysisModulesNames->str;
+ g_assert(g_queue_get_length(&reductionModules) > 0);
+ optionSyncReduction.arg= ((ReductionModule*)
+ g_queue_peek_head(&reductionModules))->name;
+ reductionModulesNames= g_string_new("Available modules: ");
+ g_queue_foreach(&reductionModules, &gfAppendReductionName,
+ reductionModulesNames);
+ // remove the last ", "
+ g_string_truncate(reductionModulesNames, reductionModulesNames->len - 2);
+ optionSyncReduction.argHelp= reductionModulesNames->str;
+
retval= snprintf(graphsDir, sizeof(graphsDir), "graphs-%d", getpid());
if (retval > sizeof(graphsDir) - 1)
{
}
optionSyncGraphs.arg= graphsDir;
+ g_queue_push_head(&moduleOptions, &optionSyncReduction);
g_queue_push_head(&moduleOptions, &optionSyncAnalysis);
g_queue_push_head(&moduleOptions, &optionSyncGraphs);
g_queue_push_head(&moduleOptions, &optionSyncStats);
testCaseName= processOptions(argc, argv);
g_string_free(analysisModulesNames, TRUE);
+ g_string_free(reductionModulesNames, TRUE);
if (optionSyncStats.present)
{
else
{
syncState->stats= false;
- g_log_set_handler(NULL, G_LOG_LEVEL_DEBUG, nullLog, NULL);
+ id= g_log_set_handler(NULL, G_LOG_LEVEL_DEBUG, nullLog, NULL);
}
if (optionSyncGraphs.present)
g_error("Analysis module '%s' not found", optionSyncAnalysis.arg);
}
+ syncState->reductionData= NULL;
+ result= g_queue_find_custom(&reductionModules, optionSyncReduction.arg,
+ &gcfCompareReduction);
+ if (result != NULL)
+ {
+ syncState->reductionModule= (ReductionModule*) result->data;
+ }
+ else
+ {
+ g_error("Reduction module '%s' not found", optionSyncReduction.arg);
+ }
+
// Initialize modules
syncState->processingModule->initProcessing(syncState, testCaseName);
syncState->matchingModule->initMatching(syncState);
syncState->analysisModule->initAnalysis(syncState);
+ syncState->reductionModule->initReduction(syncState);
// Process traceset
- syncState->processingModule->finalizeProcessing(syncState);
+ allFactors= syncState->processingModule->finalizeProcessing(syncState);
+ factors= syncState->reductionModule->finalizeReduction(syncState,
+ allFactors);
+ freeAllFactors(allFactors, syncState->traceNb);
// Write graphs file
if (syncState->graphsStream)
if (fclose(syncState->graphsStream) != 0)
{
- g_error(strerror(errno));
+ g_error("%s", strerror(errno));
}
}
// Print statistics
- if (syncState->stats)
+ if (optionSyncStats.present)
{
+ unsigned int i;
+
printStats(syncState);
+
+ printf("Resulting synchronization factors:\n");
+ for (i= 0; i < factors->len; i++)
+ {
+ Factors* traceFactors= &g_array_index(factors, Factors, i);
+ printf("\ttrace %u drift= %g offset= %g\n", i,
+ traceFactors->drift, traceFactors->offset);
+ }
}
// Destroy modules and clean up
syncState->processingModule->destroyProcessing(syncState);
syncState->matchingModule->destroyMatching(syncState);
syncState->analysisModule->destroyAnalysis(syncState);
+ syncState->reductionModule->destroyReduction(syncState);
stats= syncState->stats;
free(syncState);
endUsage.ru_stime.tv_usec);
}
+ if (!optionSyncStats.present)
+ {
+ g_log_remove_handler(NULL, id);
+ }
+
return EXIT_SUCCESS;
}
/*
- * Read program arguments dans update ModuleOptions structures
+ * Read program arguments and update ModuleOptions structures
*
* Args:
* argc, argv: standard argument arrays
extern int optind, opterr, optopt;
GArray* longOptions;
GString* optionString;
- GQueue* index;
+ GQueue* longIndex;
+ int longOption;
+ GHashTable* shortIndex;
longOptions= g_array_sized_new(TRUE, FALSE, sizeof(struct option),
g_queue_get_length(&moduleOptions));
optionString= g_string_new("");
- index= g_queue_new();
+ longIndex= g_queue_new();
+ shortIndex= g_hash_table_new(&ghfCharHash, &gefCharEqual);
g_queue_foreach(&moduleOptions, &gfAddModuleOption, &(struct OptionsInfo)
- {longOptions, optionString, index});
+ {longOptions, optionString, longIndex, shortIndex});
do
{
int optionIndex= 0;
+ ModuleOption* moduleOption;
+ longOption= -1;
c= getopt_long(argc, argv, optionString->str, (struct option*)
longOptions->data, &optionIndex);
- if (c >= 0 && c < g_queue_get_length(index))
+ if (longOption >= 0 && longOption < g_queue_get_length(longIndex))
+ {
+ moduleOption= g_queue_peek_nth(longIndex, longOption);
+ }
+ else if ((moduleOption= g_hash_table_lookup(shortIndex, &c)) != NULL)
{
- ModuleOption* moduleOption= g_queue_peek_nth(index, c);
-
- moduleOption->present= true;
-
- if (moduleOption->hasArg == REQUIRED_ARG || moduleOption->hasArg
- == OPTIONAL_ARG)
- {
- moduleOption->arg= optarg;
- }
}
else if (c == -1)
{
{
g_error("Option parse error");
}
+
+ moduleOption->present= true;
+
+ if (moduleOption->hasArg == REQUIRED_ARG)
+ {
+ moduleOption->arg= optarg;
+ }
+ if (moduleOption->hasArg == OPTIONAL_ARG && optarg)
+ {
+ moduleOption->arg= optarg;
+ }
} while (c != -1);
g_array_free(longOptions, TRUE);
g_string_free(optionString, TRUE);
+ g_queue_free(longIndex);
+ g_hash_table_destroy(shortIndex);
if (argc <= optind)
{
newOption.name= option->longName;
newOption.has_arg= conversion[option->hasArg];
newOption.flag= NULL;
- newOption.val= g_queue_get_length(optionsInfo->index);
+ newOption.val= g_queue_get_length(optionsInfo->longIndex);
g_array_append_val(optionsInfo->longOptions, newOption);
- g_string_append(optionsInfo->optionString, colons[option->hasArg]);
- g_queue_push_tail(optionsInfo->index, option);
+ if (option->shortName)
+ {
+ g_string_append_c(optionsInfo->optionString, option->shortName);
+ g_string_append(optionsInfo->optionString, colons[option->hasArg]);
+
+ g_hash_table_insert(optionsInfo->shortIndex, &option->shortName,
+ option);
+ }
+ g_queue_push_tail(optionsInfo->longIndex, option);
+}
+
+
+/*
+ * A GHashFunc for g_hash_table_new()
+ *
+ * Args:
+ * key char*, just one character
+ */
+static guint ghfCharHash(gconstpointer key)
+{
+ return *(char*) key;
+}
+
+
+/*
+ * A GEqualFunc for g_hash_table_new()
+ *
+ * Args:
+ * a, b char*, just one character each
+ *
+ * Returns:
+ * TRUE if both values are equal
+ */
+static gboolean gefCharEqual(gconstpointer a, gconstpointer b)
+{
+ if (*(char*) a == *(char*) b)
+ {
+ return TRUE;
+ }
+ else
+ {
+ return FALSE;
+ }
}
projects / lttv.git / blobdiff