int
Application_hintPause( Handle self, Bool set, int hintPause)
{
if ( !set)
return CTimer( var-> hintTimer)-> get_timeout( var-> hintTimer);
return CTimer( var-> hintTimer)-> set_timeout( var-> hintTimer, hintPause);
}
Local gint CTimer__LINUX_interval(gpointer data) {
CTimer *this = CTimer(data);
(*this->method)(this->method_object, this->method_data);
return TRUE;
}/*CTimer__WIN32_interval*/
void
Application_set_hint_action( Handle self, Handle view, Bool show, Bool byMouse)
{
if ( show && !is_opt( optShowHint)) return;
if ( show)
{
var-> hintUnder = view;
if ( var-> hintActive == -1)
{
Event ev = {cmHint};
ev. gen. B = true;
ev. gen. H = view;
((( PTimer) var-> hintTimer)-> self)-> stop( var-> hintTimer);
var-> hintVisible = 1;
if (( PWidget( view)-> stage == csNormal) &&
( CWidget( view)-> message( view, &ev)))
hshow( self);
} else {
if ( !byMouse && var-> hintActive == 1) return;
CTimer( var-> hintTimer)-> start( var-> hintTimer);
}
var-> hintActive = 1;
} else {
int oldHA = var-> hintActive;
int oldHV = var-> hintVisible;
if ( oldHA != -1)
((( PTimer) var-> hintTimer)-> self)-> stop( var-> hintTimer);
if ( var-> hintVisible)
{
Event ev = {cmHint};
ev. gen. B = false;
ev. gen. H = view;
var-> hintVisible = 0;
if (( PWidget( view)-> stage != csNormal) ||
( CWidget( view)-> message( view, &ev)))
CWidget( var-> hintWidget)-> hide( var-> hintWidget);
}
if ( oldHA != -1) var-> hintActive = 0;
if ( byMouse && oldHV) {
var-> hintActive = -1;
CTimer( var-> hintTimer)-> start( var-> hintTimer);
}
}
}
CTimer& CTimer::get(const std::string name)
{
if(allTimer_ptr == NULL) allTimer_ptr = new std::map<std::string,CTimer>;
//std::map<std::string,CTimer>::iterator it = allTimer.find(name);
std::map<std::string,CTimer>::iterator it = allTimer_ptr->find(name);
//if (it == allTimer.end())
if (it == allTimer_ptr->end())
it = allTimer_ptr->insert(std::make_pair(name, CTimer(name))).first;
//it = allTimer.insert(std::make_pair(name, CTimer(name))).first;
return it->second;
}
CEventQueueTimer*
CEventQueue::newOneShotTimer(double duration, void* target)
{
assert(duration > 0.0);
CEventQueueTimer* timer = m_buffer->newTimer(duration, true);
if (target == NULL) {
target = timer;
}
CArchMutexLock lock(m_mutex);
m_timers.insert(timer);
// initial duration is requested duration plus whatever's on
// the clock currently because the latter will be subtracted
// the next time we check for timers.
m_timerQueue.push(CTimer(timer, duration,
duration + m_time.getTime(), target, true));
return timer;
}
void
Application_HintTimer_handle_event( Handle timer, PEvent event)
{
CComponent-> handle_event( timer, event);
if ( event-> cmd == cmTimer) {
Handle self = application;
CTimer(timer)-> stop( timer);
if ( var-> hintActive == 1) {
Event ev = {cmHint};
if ( !var->hintUnder
|| apc_application_get_widget_from_point( self,
my-> get_pointerPos(self)) != var->hintUnder
|| PObject( var-> hintUnder)-> stage != csNormal)
return;
ev. gen. B = true;
ev. gen. H = var-> hintUnder;
var-> hintVisible = 1;
if (( PWidget( var-> hintUnder)-> stage == csNormal) &&
( CWidget( var-> hintUnder)-> message( var-> hintUnder, &ev)))
hshow( self);
} else if ( var-> hintActive == -1)
var-> hintActive = 0;
}
}
const unsigned int MIN_HEARD_TIME_SECS = 120U;
const int MINIMUM_DD_FRAME_LENGTH = 60;
const unsigned char ETHERNET_BROADCAST_ADDRESS[] = {0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU};
IIRC* CDDHandler::m_irc = NULL;
CHeaderLogger* CDDHandler::m_headerLogger = NULL;
int CDDHandler::m_fd = -1;
unsigned int CDDHandler::m_maxRoutes = 0U;
CEthernet** CDDHandler::m_list = NULL;
unsigned char* CDDHandler::m_buffer = NULL;
bool CDDHandler::m_logEnabled = false;
wxString CDDHandler::m_logDir = wxEmptyString;
wxString CDDHandler::m_name = wxEmptyString;
CTimer CDDHandler::m_timer = CTimer(1000U, MIN_HEARD_TIME_SECS);
CEthernet::CEthernet(const unsigned char* address, const wxString& callsign) :
m_address(NULL),
m_callsign(callsign)
{
wxASSERT(address != NULL);
wxASSERT(!callsign.IsEmpty());
m_address = new unsigned char[ETHERNET_ADDRESS_LENGTH];
::memcpy(m_address, address, ETHERNET_ADDRESS_LENGTH);
}
CEthernet::~CEthernet()
{
delete[] m_address;
void CWnd::SetTimer(ui32 nInterval)
{
m_arrTimers.Add( CTimer(this, nInterval) );
}
int main(int argc, char **argv)
{
FILE *fa, *fb;
int numRowsA, numColsA, numRowsB, numColsB, numThreads;
if(argc != 7) {
printf("usage: my_matrix_multiply -a a_matrix_file.txt -b b_matrix_file.txt -t thread_count\n");
exit(0);
}
int opt;
while ((opt = getopt(argc, argv, ARGS)) != -1) {
switch (opt) {
case 'a':
fa = fopen(optarg, "r");
break;
case 'b':
fb = fopen(optarg, "r");
break;
case 't':
numThreads = atoi(optarg);
break;
default:
fprintf(stderr, "usage: my_matrix_multiply -a a_matrix_file.txt -b b_matrix_file.txt -t thread_count\n");
exit(0);
}
}
if (fa == NULL || fb == NULL){
fprintf(stderr, "error: could not open file.\n");
exit(0);
}
if (numThreads < 1){
fprintf(stderr, "error: number of threads must be greater than 0.\n");
exit(0);
}
if(fscanf(fa, "%d %d", &numRowsA, &numColsA) < 2) {
fprintf(stderr, "error: input file for matrix A is formatted improperly.\n");
exit(0);
}
if(fscanf(fb, "%d %d", &numRowsB, &numColsB) < 2) {
fprintf(stderr, "error: input file for matrix B is formatted improperly.\n");
exit(0);
}
// check if matrix multiplication is possible
if(numColsA != numRowsB) {
fprintf(stderr, "error: Matrix multiplication not possible with given matrices.\n");
exit(0);
}
double *arrayA = (double *)malloc((numRowsA * numColsA) * sizeof(double));
double *arrayB = (double *)malloc((numRowsB * numColsB) * sizeof(double));
double *arrayC = (double *)malloc((numRowsA * numColsB) * sizeof(double));
char line[100];
int i = 0;
int j = 0;
while(fgets(line, 100, fa)) {
if(sscanf(line, "%lf", &arrayA[i]) == 1){
i++;
}
}
if(i < numRowsA * numColsA){
fprintf(stderr, "error: input file for matrix A formatted improperly.\n");
exit(0);
}
while(fgets(line, 100, fb)){
if(sscanf(line, "%lf", &arrayB[j]) == 1) {
j++;
}
}
if(j < numRowsB * numColsB){
fprintf(stderr, "error: input file for matrix B formatted improperly.\n");
exit(0);
}
fclose(fa);
fclose(fb);
struct matrix *matrixA = (struct matrix *)malloc(sizeof(struct matrix));
struct matrix *matrixB = (struct matrix *)malloc(sizeof(struct matrix));
struct matrix *matrixC = (struct matrix *)malloc(sizeof(struct matrix));
matrixA->numRows = numRowsA;
matrixA->numCols = numColsA;
matrixA->data = arrayA;
matrixB->numRows = numRowsB;
matrixB->numCols = numColsB;
matrixB->data = arrayB;
matrixC->numRows = numRowsA;
matrixC->numCols = numColsB;
matrixC->data = arrayC;
pthread_t *threads = (pthread_t *)malloc(sizeof(pthread_t)*numThreads);
struct arg_struct *args;
// make adjustment if too many threads are specified
if(numThreads > numRowsA){
numThreads = numRowsA;
}
// divide up the rows evenly amongst the threads and track the remainder
int remainderRows = numRowsA % numThreads;
int threadRows = (numRowsA - remainderRows)/numThreads;
int index = 0;
int matrixC_index = 0;
int err;
double timer = CTimer();
fflush(stdout);
for(int i = 0; i < numThreads; i++){
args = (struct arg_struct *)malloc(sizeof(struct arg_struct));
args->id = i;
args->A = matrixA;
args->B = matrixB;
args->C = matrixC;
args->index = index;
args->matrixC_index = matrixC_index;
// distribute the remainder rows amongst the first n threads
if(i < remainderRows){
args->rowsToCompute = threadRows + 1;
}
else{
args->rowsToCompute = threadRows;
}
index += numColsA * args->rowsToCompute;
matrixC_index += matrixC->numCols * args->rowsToCompute;
err = pthread_create(&(threads[i]), NULL, matrixMultiply, (void *)args);
}
for(int i = 0; i < numThreads; i++){
fflush(stdout);
err = pthread_join(threads[i], (void **)&args);
}
double timePassed = CTimer() - timer;
int it = 0;
printf("%d %d\n", args->C->numRows, args->C->numCols);
for(int i = 0; i < args->C->numRows * args->C->numCols; i++){
if(i % args->C->numCols == 0){
printf("# Row %d\n", it);
it++;
}
printf("%lf\n", args->C->data[i]);
}
free(arrayA);
free(arrayB);
free(arrayC);
free(matrixA);
free(matrixB);
free(matrixC);
free(threads);
free(args);
printf("Elapsed time: %f\n", timePassed);
return(0);
}
