OsclReturnCode OmxDecTestBase::ProcessCallbackEventHandler(OsclAny* P)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "OmxDecTestBase::ProcessCallbackEventHandler() - Processing the EventHandler Callback IN"));
// re-cast the pointer
EventHandlerSpecificData* ED = (EventHandlerSpecificData*) P;
OMX_HANDLETYPE aComponent = ED->hComponent;
OMX_PTR aAppData = ED->pAppData;
OMX_EVENTTYPE aEvent = ED->eEvent;
OMX_U32 aData1 = ED->nData1;
OMX_U32 aData2 = ED->nData2;
OMX_PTR aEventData = ED->pEventData;
EventHandler(aComponent, aAppData, aEvent, aData1, aData2, aEventData);
// release the allocated memory when no longer needed
ED->hComponent = NULL;
ED->nData1 = 0;
ED->nData2 = 0;
ED->pAppData = NULL;
ED->pEventData = NULL;
ipThreadSafeHandlerEventHandler->iMemoryPool->deallocate(ED);
PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "OmxDecTestBase::ProcessCallbackEventHandler() - OUT"));
return OsclSuccess;
}
void Engine::GameLoop()
{
SDL_Event event;
while(!State.Quit)
{
Input::Update();
// Update Input Here
while (SDL_PollEvent(&event))
{
Input::EventHandler(&event);
BaseEventHandler(event);
EventHandler(event);
if(CurrentLevel != nullptr)
{
CurrentLevel->EventHandler(&event);
}
}
Renderer->RenderClear();
// Rendering
Render();
Renderer->RenderPresent();
}
}
MainForm::MainForm()
{
SuspendLayout();
_humanBoard = gcnew Board();
_computerBoard = gcnew Board(false);
_humanPlayer = gcnew HumanPlayer("Þaidëjas", _computerBoard);
_computerPlayer = gcnew ComputerPlayer("Kompiuteris");
_scoreboard = gcnew ScoreBoard(_humanPlayer, _computerPlayer, 10, 100);
_controller = gcnew GameController(_humanPlayer, _computerPlayer, _humanBoard, _computerBoard, _scoreboard);
_shuffleButton = CreateButton(ShuffleCharacter.ToString(), ButtonBackColor);
_newGameButton = CreateButton(NewGameCharacter.ToString(), ButtonBackColor);
_startGameButton = CreateButton(StartGameCharacter.ToString(), ButtonBackColor);
SetupWindow();
LayoutControls();
_scoreboard->GameEnded += gcnew EventHandler(this, &MainForm::OnGameEnded);
_shuffleButton->Click += gcnew System::EventHandler(this, &MainForm::OnShuffleButtonClick);
_startGameButton->Click += gcnew System::EventHandler(this, &MainForm::OnStartGameButtonClick);
_newGameButton->Click += gcnew System::EventHandler(this, &MainForm::OnNewGameButtonClick);
ResumeLayout();
StartNewGame();
};
int
Game::Execute ()
{
if( Init() == false )
return 1;
else{
pTimer = new Timer();
m_IsRunning = true;
SDL_Event event;
while( m_IsRunning ){
pTimer->start();
while( SDL_PollEvent( &event ) ){
EventHandler( &event );
}
Update();
Render();
//Limit max frame rate per second( FPS )
if( pTimer->getTicks() < 1000 / 60 )
SDL_Delay( ( 1000 / 60 ) - pTimer->getTicks() );
}
}
return 0;
}
void one() {
#ifndef TEST_EMSCRIPTEN_SDL_SETEVENTHANDLER
SDL_Event event;
while (SDL_PollEvent(&event)) {
EventHandler(0, &event);
}
#endif
}
TiendaEscena::TiendaEscena() {
onTimerTick = gcnew EventHandler(this, &TiendaEscena::timerTick);
onKeyDown = gcnew KeyEventHandler(this, &TiendaEscena::teclaDown);
onMouseClick = gcnew MouseEventHandler(this, &TiendaEscena::mouseClick);
modo_comprar = false;
modo_vender = true;
crearCartas();
}
/////////////////////////////////////////////////////////////////////////
// Programme principal
/////////////////////////////////////////////////////////////////////////
int main()
{
printf("Demarrage du programme\n\r") ;
Init() ;
while(true) {
// Appel au gestionnaire d'evenements
giEvent = EventHandler() ;
// Appel a la machine a etats
Algo() ;
}
}
void LiveInLight (void){
PORTB &= ~(1<<LedPin); // Light-up LED
PWMStop();
while (1){
EnableInput ();
DeepSleep();
DisableInput ();
if (Valto != None) {
EventHandler ();
// if key pressed then shutdown
if (Valto==KeyPressed) break;
}
}
PWMStart(250);
PORTB |= (1<<LedPin); // Shutdown LED
}
void LightUp (void){
uint8_t i;
PWMStart(0);
// Enable shutdown at Light-up
for (i=0; i<=250; i++){
PWMSet (i);
EnableInput ();
if (i<PWMStepOver) Wait (PWMSlowDelay);
else Wait (PWMQuickDelay);
DisableInput ();
if (Valto != None) {
EventHandler ();
// if key pressed then shutdown
if (Valto==KeyPressed) break;
}
}
}
int main (void){
// Setup IO
DDRB = (0<<PB0)|(1<<PB1)|(0<<PB2)|(0<<PB3)|(0<<PB4);
PORTB = (1<<PB0)|(1<<PB1)|(1<<PB2)|(0<<PB3)|(0<<PB4); // VCC-based LED
while (1){
EnableInput ();
DeepSleep();
DisableInput ();
// **** Why wake? ****
EventHandler();
if (Valto==KeyPressed) {
Valto = None;
Wait (_2_s);
LightUp();
if (Valto == None) LiveInLight();
LightDown();
}
}
}
CampusEscena::CampusEscena()
{
onTimerTick = gcnew EventHandler(this, &CampusEscena::timerTick);
onKeyDown = gcnew KeyEventHandler(this, &CampusEscena::teclaDown);
onKeyUp = gcnew KeyEventHandler(this, &CampusEscena::teclaUp);
onMouseClick = gcnew MouseEventHandler(this, &CampusEscena::mouseClick);
Mapas::plazuela_mapa = gcnew PlazuelaMapa();
Mapas::pabellonA_mapa = gcnew PabellonAMapa();
Mapas::pabellonB_mapa = gcnew PabellonBMapa();
Mapas::sotano_mapa = gcnew SotanoMapa();
Mapas::jardin_mapa = gcnew JardinMapa();
Mapa::mapa_actual = Mapas::plazuela_mapa;
Marco::marco = gcnew Marco(gcnew Posicion(9, 9, true));
PROFESORES::Profesor1 = gcnew Profesor(1, Mapas::plazuela_mapa, gcnew Posicion(16, 3, true));
PROFESORES::Profesor2 = gcnew Profesor(3, Mapas::pabellonB_mapa, gcnew Posicion(16, 11, true));
PROFESORES::Profesor3 = gcnew Profesor(5, Mapas::sotano_mapa, gcnew Posicion(16, 6, true));
PROFESORES::Profesor4 = gcnew Profesor(7, Mapas::jardin_mapa, gcnew Posicion(11, 4, true));
PROFESORES::Profesor5 = gcnew Profesor(9, Mapas::pabellonA_mapa, gcnew Posicion(2, 10, true));
}
//=========================================================================
//----- (00000148) --------------------------------------------------------
__myevic__ void Main()
{
InitDevices();
InitVariables();
// Enable chip temp sensor sampling by ADC
if ( ISRX300 )
{
SYS->IVSCTL |= SYS_IVSCTL_VTEMPEN_Msk;
}
InitHardware();
myprintf( "\n\nJoyetech APROM\n" );
myprintf( "CPU @ %dHz(PLL@ %dHz)\n", SystemCoreClock, PllClock );
SetBatteryModel();
gFlags.sample_vbat = 1;
ReadBatteryVoltage();
gFlags.sample_btemp = 1;
ReadBoardTemp();
InitDisplay();
MainView();
SplashTimer = 3;
CustomStartup();
if ( !PD3 )
{
DrawScreen();
while ( !PD3 )
;
}
while ( 1 )
{
while ( gFlags.playing_fb )
{
// Flappy Bird game loop
fbCallTimeouts();
if ( gFlags.tick_100hz )
{
// 100Hz
gFlags.tick_100hz = 0;
ResetWatchDog();
TimedItems();
SleepIfIdle();
GetUserInput();
if ( !PE0 )
SleepTimer = 3000;
}
if ( gFlags.tick_10hz )
{
// 10Hz
gFlags.tick_10hz = 0;
DataFlashUpdateTick();
}
}
if ( gFlags.firing )
{
ReadAtoCurrent();
}
if ( gFlags.tick_5khz )
{
// 5000Hz
gFlags.tick_5khz = 0;
if ( gFlags.firing )
{
RegulateBuckBoost();
}
}
if ( gFlags.tick_1khz )
{
// 1000Hz
gFlags.tick_1khz = 0;
if ( gFlags.firing )
{
ReadAtomizer();
if ( ISMODETC(dfMode) )
{
if ( gFlags.check_mode )
{
CheckMode();
}
TweakTargetVoltsTC();
}
else if ( ISMODEVW(dfMode) )
{
TweakTargetVoltsVW();
}
}
if ( dfStatus.vcom )
{
VCOM_Poll();
}
}
if ( gFlags.tick_100hz )
{
// 100Hz
gFlags.tick_100hz = 0;
ResetWatchDog();
if ( gFlags.read_battery )
{
gFlags.read_battery = 0;
}
TimedItems();
SleepIfIdle();
ReadBatteryVoltage();
ReadBoardTemp();
if ( gFlags.firing && BoardTemp >= 70 )
{
Overtemp();
}
if ( ISVTCDUAL )
{
BatteryChargeDual();
}
else if ( ISCUBOID || ISCUBO200 || ISRX200S || ISRX23 || ISRX300 )
{
BatteryCharge();
}
if (( gFlags.anim3d ) && ( Screen == 1 ) && ( !EditModeTimer ))
{
anim3d( 0 );
}
if ( Screen == 60 )
{
AnimateScreenSaver();
}
if ( gFlags.firing )
{
if ( gFlags.read_bir && ( FireDuration > 10 ) )
{
ReadInternalResistance();
}
if ( PreheatTimer && !--PreheatTimer )
{
uint16_t pwr;
if ( dfMode == 6 )
{
pwr = dfSavedCfgPwr[ConfigIndex];
}
else
{
pwr = dfPower;
}
if ( pwr > BatteryMaxPwr )
{
gFlags.limit_power = 1;
PowerScale = 100 * BatteryMaxPwr / pwr;
}
else
{
gFlags.limit_power = 0;
PowerScale = 100;
}
}
}
if ( KeyTicks >= 5 )
{
KeyRepeat();
}
GetUserInput();
}
if ( gFlags.tick_10hz )
{
// 10Hz
gFlags.tick_10hz = 0;
DataFlashUpdateTick();
LEDTimerTick();
if ( gFlags.firing )
{
++FireDuration;
if ( gFlags.monitoring )
{
Monitor();
}
}
if ( ShowWeakBatFlag )
--ShowWeakBatFlag;
if ( ShowProfNum )
--ShowProfNum;
if ( !( gFlags.firing && ISMODETC(dfMode) ) )
{
DrawScreen();
}
if ( KeyTicks < 5 )
{
KeyRepeat();
}
}
if ( gFlags.tick_5hz )
{
// 5Hz
gFlags.tick_5hz = 0;
if ( !gFlags.rtcinit && NumBatteries )
{
InitRTC();
}
if ( gFlags.firing )
{
if ( TargetVolts == 0 )
{
ProbeAtomizer();
}
}
else
{
if
( !dfStatus.off
&& Event == 0
&& ( AtoProbeCount < 12 )
&& ( Screen == 0 || Screen == 1 || Screen == 5 ) )
{
ProbeAtomizer();
}
}
if ( IsClockOnScreen() )
{
static uint8_t u8Seconds = 61;
S_RTC_TIME_DATA_T rtd;
GetRTC( &rtd );
if ( (uint8_t)rtd.u32Second != u8Seconds )
{
u8Seconds = (uint8_t)rtd.u32Second;
gFlags.refresh_display = 1;
}
}
}
if ( gFlags.tick_2hz )
{
// 2Hz
gFlags.tick_2hz = 0;
gFlags.osc_1hz ^= 1;
if ( gFlags.firing )
{
if ( ISMODETC(dfMode) )
{
DrawScreen();
}
}
else
{
if
( !dfStatus.off
&& Event == 0
&& ( AtoProbeCount >= 12 )
&& ( Screen == 0 || Screen == 1 || Screen == 5 ) )
{
ProbeAtomizer();
}
if ( gFlags.monitoring )
{
Monitor();
}
}
}
if ( gFlags.tick_1hz )
{
// 1Hz
gFlags.tick_1hz = 0;
if ( SplashTimer )
{
--SplashTimer;
if ( !SplashTimer )
{
MainView();
}
}
if ( !gFlags.firing && !dfStatus.off && !EditModeTimer )
{
if ( HideLogo )
{
if ( Screen == 1 )
{
--HideLogo;
if ( !HideLogo )
{
gFlags.refresh_display = 1;
}
}
}
}
}
EventHandler();
}
}
function Init() {
/* Global colors. May move them elsehwere in the future.
*/
LoadTheme("Default.txt");
/* Uncomment to use US english day/month strings instead of whatever Windows
* is configured to use.
*/
// SetLocale(0x0409, 1);
/* Enable low-level communication with the G15. Makes playing with lights faster,
* allows V1/V2 differentiation, enables display when LCDMon.exe is not running,
* allows g- and m-key handling, etc. Does not break compatibility when LCDMon is
* running.
*/
G15EnableHID();
/* Will steal LCD when started. Remove/comment out line to change that.
* Was added in the hope that it would cause the G19 to display LCD Miscellany instead
* of the app list. Unfortunately, doesn't do that. Note that this will make the first
* update only high priority. Will return to normal afterwards.
*/
G15SetPriority(LGLCD_PRIORITY_ALERT);
eventHandler = EventHandler();
/* Change order (or comment out) to change order of views (or hide them)
*/
menuHandler = MenuHandler(eventHandler,
DualView (
StatusView(
//DefaultStatus(),
QuadStatus(),
GameStatus(),
// Sample screen with speedfan info. Useful for figuring out which
// number is what.
// SpeedFanStatus(),
),
StatusView(
G19Status(),
)
),
// Change 0 to 1 to disable stealing non-media keys when focused.
TaskManager(0),
MediaView(
MPCController(),
VLCController(),
WinampController(),
ItunesController(),
// Really, really slow, probably because of DDE.
// AMIPController(),
),
TextEditorView(),
ClipboardView(),
CalculatorView(),
// Specify urls like the next line, or modify ini:
// RSSView(RSS_DISPLAY_TITLE | RSS_DISPLAY_DESCRIPTION,RSS_DISPLAY_TITLE | RSS_DISPLAY_DESCRIPTION,"http://news.google.com/?rss=&output=rss"),
RSSView(
RSS_DISPLAY_TITLE | RSS_DISPLAY_DESCRIPTION, // Channel title flags
RSS_DISPLAY_TITLE | RSS_DISPLAY_DESCRIPTION, // Item text flags
, // URL to use. Can either be a string or a list of strings. If left null, uses one in ini.
// Channels to display. Currently, can only specify one per entry in previous parameter.
),
// uTorrent.
DownloadView(),
// Note: SABnzbdView works fine, but is currently only formatted for G15s.
// Delete the first "/*" to show it.
// SABnzbdView 0.1.9 by 4wd:
// Parameters are: SABnzbdView(URL, header, subview),
// Where: URL = "http://ip:port/sabnzbd/"
// header = 0 if you want the TIME/DATE header
// 1 if you want IP:Port header
// subview = 0 if not using StatusView for multiple views
// 1 if using StatusView (allows Pause/Resume/Stop)
//
// For SABnzbd+ 0.4.9 or higher the URL must be:
// URL = "http://ip:port/sabnzbd/api?apikey=<insert key>"
//
// If you are only interested in one SABnzbd+ daemon, you can leave the
// URL empty and place it in the LCDMisc.ini under [URLs]. See the example.
/* SABnzbdView(, 0, 0), //*/
// The sample below shows using StatusView to monitor more than one SABnzbd+
// Switching between screens is done by pressing the LCDMisc 'OK' button,
// (third LCD button). URL is required when using StatusView.
// You can mix URLs for SABnzbd+ versions.
/*
StatusView("Images\SABnzbd.png",
SABnzbdView("http://1.2.3.4:8080/sabnzbd/",1, 1),
SABnzbdView("http://5.6.7.8:8080/sabnzbd/api?apikey=77e45017",1, 1)
),
*/
/* Parameters aren't needed, but replace the 0 with a 1 to display location
* instead of time at the top, over the header (Small LCDs only). No room for both,
* unfortunately. Could squeeze the location and either the date or time on
* together for most location names, but not all, so sticking with either-or
* for now.
*/
WeatherView(,0),
// Sample showing how to use a StatusView to let you switch between
// weather screens. Note that the first is in Fahrenheit and second
// is in Celsuis. Just uncomment (Delete the "/*") and change/add
// urls as needed.
/*
StatusView(
WeatherView("http://xml.weather.yahoo.com/forecastrss?p=usma0066&u=f", 1),
WeatherView("http://xml.weather.yahoo.com/forecastrss?p=CAXX0487&u=c", 1)
),
//*/
);
// Turn off lights during screensaver. Delete the "//" to enable.
// ScreenSaverLightToggle(eventHandler);
/* Smoothes out system volume changes. Note that it doesn't steal the
* volume wheel. Instead, it monitors the system volume setting.
* It will partially break the Windows Master volume slider.
* Intended to rectify the default ~4% adjustment per tick of the
* volume wheel, which is much too coarse if you use a lower setting.
* Experimental, breaks dragging on master volume control. Vista
* already uses smaller increments, so not useful there.
*/
//VolumeSmoother(eventHandler);
// Tray icons. Uncomment whichever ones you like.
//AddCpuIcon();
//AddTotalCpuIcon();
//AddNetIcon();
}
IntroduccionEscena::IntroduccionEscena() {
onTimerTick = gcnew EventHandler(this, &IntroduccionEscena::timerTick);
onKeyDown = gcnew KeyEventHandler(this, &IntroduccionEscena::teclaDown);
}
/*
* @function main
*/
int main( int argc, const char** argv ) {
// Get the mode
if (argc > 1)
{
const char *inputMode = argv[1];
if (strcmp(inputMode, "normal") == 0) {
mode = NORMAL;
} else if (strcmp(inputMode, "debug") == 0) {
mode = DEBUG;
} else if (strcmp(inputMode, "plot") == 0) {
mode = PLOT;
} else {
mode = NORMAL;
}
}
else
{
mode = NORMAL;
}
if (mode == NORMAL) {
eventHandler = EventHandler();
}
if (mode == DEBUG || mode == NORMAL) {
printf("Input Mode: %s\n", mode == NORMAL ? "normal" :
mode == DEBUG ? "debug" :
mode == PLOT ? "plot" : "none");
cv::namedWindow(main_window_name,CV_WINDOW_NORMAL);
cv::moveWindow(main_window_name, 400, 100);
cv::namedWindow(face_window_name,CV_WINDOW_NORMAL);
cv::moveWindow(face_window_name, 10, 100);
cv::namedWindow("Right Eye",CV_WINDOW_NORMAL);
cv::moveWindow("Right Eye", 10, 600);
cv::namedWindow("Left Eye",CV_WINDOW_NORMAL);
cv::moveWindow("Left Eye", 10, 800);
} else if (mode == PLOT) {
cv::namedWindow(face_window_name,CV_WINDOW_NORMAL);
cv::moveWindow(face_window_name, 400, 100);
}
cv::Mat frame;
// Load the cascades
if( !face_cascade.load( FACE_CASCADE_FILE ) ){ printf("--(!)Error loading face cascade, please change face_cascade_name in source code.\n"); return -1; };
// Read the video stream
cv::VideoCapture capture( 0 );
if( capture.isOpened() ) {
capture.set(CV_CAP_PROP_FRAME_WIDTH, 640);
capture.set(CV_CAP_PROP_FRAME_HEIGHT, 480);
capture.set(CV_CAP_PROP_FPS, 15);
capture >> frame;
while( true ) {
capture >> frame;
// mirror it
cv::flip(frame, frame, 1);
frame.copyTo(debugImage);
// Apply the classifier to the frame
if( !frame.empty() ) {
detectAndDisplay( frame );
}
else {
printf(" --(!) No captured frame -- Break!");
break;
}
if (mode == DEBUG || mode == NORMAL) {
imshow(main_window_name, debugImage);
}
if (mode == DEBUG || mode == PLOT || mode == NORMAL) {
int c = cv::waitKey(10);
if( (char)c == 'c' ) { break; }
if( (char)c == 'f' ) {
imwrite("frame.png", frame);
}
}
}
}
bool xmpp_dummy::Handler(IMEvent* event) {
if (EventHandler()) {
return EventHandler()->Handler(event);
}
return IMEventHandler::Handler(event);
}
int main(int argc, char *argv[]) {
time_t newStart, newEnd;
time(&newStart);
// double first, second;
// first = CPU_TIME;
// clock_t start = clock();
setbuf(stdout, NULL); // debugguing mode
event *eventList, *ptrAuxList, *ptrLastNode;
machine *machineList, *ptrAuxMachine;
task *taskList, *orderedTaskList;
job *jobList;
taskAccountInfo *taskAccountInfoList;
gridAccountInfo *gridInfoList;
jobAccountInfo *jobAccountInfoList;
balanceAccountInfo *balanceAccountInfoList;
schedule *scheduleList;
unsigned long int count = 0;
unsigned long int totalNumberOfEvents = 0;
gridMachinesID = 0; scheduleID = 0;
aggregatedUtility = 0; aggregatedCost =0; aggregatedProfit = 0;
// balanceCredit = 0;
// unsigned long int totalUtility = 0;
// float totalCost = 0.0, totalProfit = 0.0;
if (argc == 14) {
optFlag = (atoi(argv[1]));
simulationTime = ((atoi(argv[2]) * 24 * 60) + 1440); // simulationTime is a global variable (minutes) based on the input parameter (days)
jobSize = (atoi(argv[3]));
gridQoSFactor = (atof(argv[4]));
ondemandPriceFactor = (atof(argv[5]));
inhouseFactor = (atof(argv[6]));
numberOfLocalMachines = (atoi(argv[7]));
numberOfReservedMachines = atoi(argv[8]);
numberOfOnDemandMachines = atoi(argv[9]);
if (atoi(argv[10]) == 0) {
taskAvgTime = 10;
taskSdvTime = 5;
} else {
taskAvgTime = 47;
taskSdvTime = 26;
}
gridAvgUptime = (atoi(argv[11]));
utilityFunction = (atoi(argv[12]));
simSeed = (atoi(argv[13]));
ondemandUsagePrice = (0.08*ondemandPriceFactor); reservedUsagePrice = 0.064; reservationPrice = 124.00;
reservationPricePerDay = (numberOfReservedMachines * reservationPrice)/365;
srand(simSeed);
// starting a new event list
if ( (eventList = malloc(sizeof(event))) ) {
// start simulation event
eventList->eventNumber = 0; eventList->eventID = 0; eventList->time = 0; eventList->flag = -1; eventList->nextEvent = NULL;
} else printf("ERROR (main simulator): merdou o malloc!!!\n");
// finish simulation event
if ( (ptrLastNode = malloc(sizeof(event))) ) {
ptrLastNode->eventNumber = 1; ptrLastNode->eventID = SIMFINNISHED; ptrLastNode->time = (simulationTime+1); ptrLastNode->flag = -1; ptrLastNode->nextEvent = NULL;
} else printf("ERROR (main simulator): merdou o malloc!!!\n");
eventList->nextEvent = ptrLastNode;
ptrThisEvent = eventList;
// filling the event list with local and grid (???) machines, and workload jobs and tasks
FillEmptyEventList(eventList);
// IMPLEMENTAR AS VARIANTES PARA O FILLEMPTYEVENTLIST();
// ptrAuxAux = eventList;
// int count1 = 0;
// while(ptrAuxAux) {
// count1++;
// if (ptrAuxAux->eventID == 1 || ptrAuxAux->eventID == 2) {
// printf("eventID %d time %d machineID %d source %d status %d AT %d DT %d UP %.2f RP %.2f\n", ptrAuxAux->eventID, ptrAuxAux->time, ptrAuxAux->machineInfo.machineID,
// ptrAuxAux->machineInfo.source, ptrAuxAux->machineInfo.status, ptrAuxAux->machineInfo.arrivalTime, ptrAuxAux->machineInfo.departureTime,
// ptrAuxAux->machineInfo.usagePrice, ptrAuxAux->machineInfo.reservationPrice);
// }
// ptrAuxAux = ptrAuxAux->nextEvent;
// }
// printf("a lista tem %d eventos\n", count1);
// printf("\n");
// starting a machine list
if ( (machineList = malloc(sizeof(machine))) ) {
machineList->machineID = 0; // 0 means code for an empty machine list
machineList->nextMachine = NULL;
}
else {
printf("ERROR (main simulator): merdou o malloc!!!\n");
}
// starting a task list
if ( (taskList = malloc(sizeof(task))) ) {
taskList->taskID = 0; // 0 means code for an empty task list
taskList->nextTask = NULL;
}
else {
printf("ERROR (main simulator): merdou o malloc!!!\n");
}
// starting an ordered task list
if ( (orderedTaskList = malloc(sizeof(task))) ) {
orderedTaskList->taskID = 0; // 0 means code for an empty task list
orderedTaskList->nextTask = NULL;
}
else {
printf("ERROR (main simulator): merdou o malloc!!!\n");
}
// starting a job list
if ( (jobList = malloc(sizeof(job))) ) {
jobList->jobID = 0; // 0 means code for an empty job list
jobList->nextJob = NULL;
}
else {
printf("ERROR (main simulator): merdou o malloc!!!\n");
}
// starting an account list to register the execution of tasks
if ( (taskAccountInfoList = malloc(sizeof(taskAccountInfo))) ) {
taskAccountInfoList->taskAccountID = 0; // 0 means code for an empty task list
taskAccountInfoList->status = ACCOUNTUNFINNISHED;
taskAccountInfoList->nextTaskAccountInfo = NULL;
}
else {
printf("ERROR (main simulator): merdou o malloc!!!\n");
}
// starting an account list to register the execution of jobs
if ( (jobAccountInfoList = malloc(sizeof(jobAccountInfo))) ) {
jobAccountInfoList->jobAccountID = 0; // 0 means code for an empty task list
jobAccountInfoList->nextJobAccountInfo = NULL;
}
else {
printf("ERROR (main simulator): merdou o malloc!!!\n");
}
// starting an account list to register the donations to the grid
if ( (gridInfoList = malloc(sizeof(gridAccountInfo))) ) {
gridInfoList->gridAccountID = 0; // 0 means code for an empty task list
gridInfoList->nextGridAccountInfo = NULL;
}
else {
printf("ERROR (main simulator): merdou o malloc!!!\n");
}
// starting a balance account list
if ( (balanceAccountInfoList = malloc(sizeof(balanceAccountInfo))) ) {
balanceAccountInfoList->balanceAccountID = 0;
balanceAccountInfoList->time = 0;
balanceAccountInfoList->value = 0;
balanceAccountInfoList->nextBalanceAccountInfo = NULL;
}
else {
printf("ERROR (main simulator): merdou o malloc!!!\n");
}
// starting a schedule list
if ( (scheduleList = malloc(sizeof(schedule))) ) {
scheduleList->scheduleID = 0;
scheduleList->nextSchedule = NULL;
}
else {
printf("ERROR (main simulator): merdou o malloc!!!\n");
}
ptrLastBalance = balanceAccountInfoList;
ptrAuxList = eventList;
long int lastEventNumber = -1;
unsigned long int lastEventTime = 0;
unsigned long int numberOfArrivals = 0, numberOfDepartures = 0;
// int count = 0;
while(ptrAuxList) {
// if(ptrAuxList->time > (simulationTime + 1)) break;
ptrThisEvent = ptrAuxList;
// printf("event# %d eventID %d ", ptrAuxList->eventNumber, ptrAuxList->eventID);
printf("event# %ld ", ptrAuxList->eventNumber);
switch (ptrAuxList->eventID) {
case 0:
EventHandler(ptrAuxList, &eventList, &machineList, &taskList, &taskAccountInfoList, gridInfoList, jobList, jobAccountInfoList,
&balanceAccountInfoList, &orderedTaskList, scheduleList);
break;
case 1: // Machine Arrival
EventHandler(ptrAuxList, &eventList, &machineList, &taskList, &taskAccountInfoList, gridInfoList, jobList, jobAccountInfoList,
&balanceAccountInfoList, &orderedTaskList, scheduleList);
break;
case 2: // Machine Departure
EventHandler(ptrAuxList, &eventList, &machineList, &taskList, &taskAccountInfoList, gridInfoList, jobList, jobAccountInfoList,
&balanceAccountInfoList, &orderedTaskList, scheduleList);
break;
case 3: // Grid Donating
EventHandler(ptrAuxList, &eventList, &machineList, &taskList, &taskAccountInfoList, gridInfoList, jobList, jobAccountInfoList,
&balanceAccountInfoList, &orderedTaskList, scheduleList);
break;
case 4: // Grid Preempted
EventHandler(ptrAuxList, &eventList, &machineList, &taskList, &taskAccountInfoList, gridInfoList, jobList, jobAccountInfoList,
&balanceAccountInfoList, &orderedTaskList, scheduleList);
break;
case 5: // Task Arrival
EventHandler(ptrAuxList, &eventList, &machineList, &taskList, &taskAccountInfoList, gridInfoList, jobList, jobAccountInfoList,
&balanceAccountInfoList, &orderedTaskList, scheduleList);
break;
case 6: // Task Schedule
EventHandler(ptrAuxList, &eventList, &machineList, &taskList, &taskAccountInfoList, gridInfoList, jobList, jobAccountInfoList,
&balanceAccountInfoList, &orderedTaskList, scheduleList);
break;
case 7: // Task Preempted
EventHandler(ptrAuxList, &eventList, &machineList, &taskList, &taskAccountInfoList, gridInfoList, jobList, jobAccountInfoList,
&balanceAccountInfoList, &orderedTaskList, scheduleList);
break;
case 8: // Task Finnished
EventHandler(ptrAuxList, &eventList, &machineList, &taskList, &taskAccountInfoList, gridInfoList, jobList, jobAccountInfoList,
&balanceAccountInfoList, &orderedTaskList, scheduleList);
break;
case 9: // Job Arrival
EventHandler(ptrAuxList, &eventList, &machineList, &taskList, &taskAccountInfoList, gridInfoList, jobList, jobAccountInfoList,
&balanceAccountInfoList, &orderedTaskList, scheduleList);
break;
case 10: // Job Started
EventHandler(ptrAuxList, &eventList, &machineList, &taskList, &taskAccountInfoList, gridInfoList, jobList, jobAccountInfoList,
&balanceAccountInfoList, &orderedTaskList, scheduleList);
break;
case 11: // Job Finnished
EventHandler(ptrAuxList, &eventList, &machineList, &taskList, &taskAccountInfoList, gridInfoList, jobList, jobAccountInfoList,
&balanceAccountInfoList, &orderedTaskList, scheduleList);
break;
case 12: // Allocation Planning
EventHandler(ptrAuxList, &eventList, &machineList, &taskList, &taskAccountInfoList, gridInfoList, jobList, jobAccountInfoList,
&balanceAccountInfoList, &orderedTaskList, scheduleList);
break;
case 13: // Simulation Finnished
EventHandler(ptrAuxList, &eventList, &machineList, &taskList, &taskAccountInfoList, gridInfoList, jobList, jobAccountInfoList,
&balanceAccountInfoList, &orderedTaskList, scheduleList);
break;
default:
printf("unkwonk event!!!\n");
break;
}
// ##### INVARIANTES PARA A LISTA DE EVENTOS #####
totalNumberOfEvents++;
// testar se o atual eh o anterior - 1
if ( (ptrAuxList->eventNumber - 1) != lastEventNumber ) {
// printf("\n");
printf("(INVARIANTES) NUMERACAO DOS EVENTOS ESTA ERRADA!!!\n");
break;
}
lastEventNumber = ptrAuxList->eventNumber;
// testas se o tempo estah crescente
if (ptrAuxList->time < lastEventTime) {
// printf("\n");
printf("(INVARIANTES) EVENTOS NAO ESTAO EM ORDEM DECRESCENTE!!!\n");
break;
}
lastEventTime = ptrAuxList->time;
// testar se o numero de chegadas de maquinas eh igual ao de partida
if (ptrAuxList->eventID == MACHARRIVAL) numberOfArrivals++;
if (ptrAuxList->eventID == MACHDEPARTURE) numberOfDepartures++;
// atualizar o ponteiro para lista de eventos e remover o noh anterior
event *ptrLastEvent;
ptrLastEvent = ptrAuxList;
ptrAuxList = ptrAuxList->nextEvent; // passa pro proximo evento
if ( ptrAuxList != NULL && (ptrAuxList->time > ptrLastEvent->time) ) {
event *ptrAuxEvent;
ptrAuxEvent = eventList;
eventList = ptrAuxList;
while(ptrAuxEvent != ptrLastEvent) {
event *ptrRemove;
ptrRemove = ptrAuxEvent;
ptrAuxEvent = ptrAuxEvent->nextEvent;
free(ptrRemove);
ptrRemove = NULL;
}
if (ptrAuxEvent == ptrLastEvent) {
free(ptrLastEvent);
ptrLastEvent = NULL;
ptrAuxEvent = NULL;
}
}
} // end of while(ptrAuxList)
// printf("\n");
// testando a numeracao de eventos
if ( totalNumberOfEvents != (lastEventNumber+1) ) {
// printf("\n");
printf("(INVARIANTES) NUMERO ERRADO DE EVENTOS!!!\n");
// printf("\n");
}
// testando o numero de chegadas e partidas de maquinas
if (numberOfArrivals != numberOfDepartures) {
// printf("\n");
printf("(INVARIANTES) NUMERO DE CHEGADAS DIFERENTE DO NUMERO DE SAIDAS!!!\n");
}
// ##### FIM DAS INVARIANTES PARA A LISTA DE EVENTOS #####
// CIRAR UM TESTE DEPOIS PARA SABER SE TODAS AS TASKS FORAM EXECUTADAS OU NAO
// FILE *ptrFileJobAccountInfo;
// ptrFileJobAccountInfo = fopen("jobaccountinfo.txt", "a+");
// jobAccountInfo *ptrAuxJobAccountInfo;
// ptrAuxJobAccountInfo = jobAccountInfoList;
// count = 0;
// while(ptrAuxJobAccountInfo) {
// count++;
// fprintf(ptrFileJobAccountInfo, "jobAccountID %d jobID %d ST %ld FT %ld\n", ptrAuxJobAccountInfo->jobAccountID, ptrAuxJobAccountInfo->jobID, ptrAuxJobAccountInfo->startTime, ptrAuxJobAccountInfo->finnishTime);
// ptrAuxJobAccountInfo = ptrAuxJobAccountInfo->nextJobAccountInfo;
// }
// // printf("a lista de jobs tem %d registros\n", count);
// // printf("\n");
// fclose(ptrFileJobAccountInfo);
// FILE *ptrFileJobList;
// ptrFileJobList = fopen("joblist.txt", "a+");
// job *ptrAuxJob;
// ptrAuxJob = jobList;
// count = 0;
// while(ptrAuxJob) {
// count++;
// totalCost += ptrAuxJob->cost;
// totalUtility += ptrAuxJob->utility;
// totalProfit += (ptrAuxJob->utility - ptrAuxJob->cost);
// fprintf(ptrFileJobList, "jobID %d jobSize %d AR %ld FT %ld LT %d DL %ld MU %ld Utility %ld Cost %.2f Profit %.2f\n", ptrAuxJob->jobID, ptrAuxJob->jobSize, ptrAuxJob->arrivalTime, ptrAuxJob->finnishTime, ptrAuxJob->longestTask,
// ptrAuxJob->deadline, ptrAuxJob->maxUtility, ptrAuxJob->utility, ptrAuxJob->cost, (ptrAuxJob->utility - ptrAuxJob->cost));
// ptrAuxJob = ptrAuxJob->nextJob;
// }
// // printf("\n");
// fclose(ptrFileJobList);
// FILE *ptrFileTaskList;
// ptrFileTaskList = fopen("tasklist.txt", "a+");
// task *ptrAuxTask;
// ptrAuxTask = taskList;
// count = 0;
// while(ptrAuxTask) {
// count++;
// fprintf(ptrFileTaskList, "taskID %d jobID %d jobSize %d AR %ld RT %d status %d submissions %d\n", ptrAuxTask->taskID, ptrAuxTask->jobID, ptrAuxTask->jobSize,
// ptrAuxTask->arrivalTime, ptrAuxTask->runtime, ptrAuxTask->status, ptrAuxTask->numberOfSubmissions);
// ptrAuxTask = ptrAuxTask->nextTask;
// }
// // printf("\n");
// task *ptrAuxOrderedTask;
// ptrAuxOrderedTask = orderedTaskList;
// count = 0;
// while(ptrAuxOrderedTask) {
// count++;
// fprintf(ptrFileTaskList, "taskID %d jobID %d jobSize %d AR %ld RT %d status %d submissions %d\n", ptrAuxOrderedTask->taskID, ptrAuxOrderedTask->jobID, ptrAuxOrderedTask->jobSize,
// ptrAuxOrderedTask->arrivalTime, ptrAuxOrderedTask->runtime, ptrAuxOrderedTask->status, ptrAuxOrderedTask->numberOfSubmissions);
// ptrAuxOrderedTask = ptrAuxOrderedTask->nextTask;
// }
// // printf("\n");
// fclose(ptrFileTaskList);
// FILE *ptrFileScheduleList;
// ptrFileScheduleList = fopen("schedulelist.txt", "a+");
// schedule *ptrAuxSchedule;
// ptrAuxSchedule = scheduleList;
// while(ptrAuxSchedule) {
// fprintf(ptrFileScheduleList, "scheduleID %d scheduleTime %d machineID %d source %d taskID %d jobID %d RT %d\n", ptrAuxSchedule->scheduleID, ptrAuxSchedule->scheduleTime, ptrAuxSchedule->machineID,
// ptrAuxSchedule->source, ptrAuxSchedule->taskID, ptrAuxSchedule->jobID, ptrAuxSchedule->runtime);
// ptrAuxSchedule = ptrAuxSchedule->nextSchedule;
// }
// fclose(ptrFileScheduleList);
// // ##### INVARIANTES PARA A LISTA DE EVENTOS #####
// event *ptrAuxEventList;
// ptrAuxEventList = eventList;
// int lastEventNumber = -1;
// unsigned int lastEventTime = 0;
// unsigned short int numberOfArrivals = 0, numberOfDepartures = 0;
// while(ptrAuxEventList) {
// totalNumberOfEvents++;
//
// // testar se o atual eh o anterior - 1
// if ( (ptrAuxEventList->eventNumber - 1) != lastEventNumber ) {
// // printf("\n");
// printf("(INVARIANTES) NUMERACAO DOS EVENTOS ESTA ERRADA!!!\n");
// break;
// }
// lastEventNumber = ptrAuxEventList->eventNumber;
//
// // testas se o tempo estah crescente
// if (ptrAuxEventList->time < lastEventTime) {
// // printf("\n");
// printf("(INVARIANTES) EVENTOS NAO ESTAO EM ORDEM DECRESCENTE!!!\n");
// break;
// }
//
// // testar se o numero de chegadas de maquinas eh igual ao de partida
// if (ptrAuxEventList->eventID == MACHARRIVAL) numberOfArrivals++;
// if (ptrAuxEventList->eventID == MACHDEPARTURE) numberOfDepartures++;
//
// ptrAuxEventList = ptrAuxEventList->nextEvent;
//
// }
//
// // testando a numeracao de eventos
// if ( totalNumberOfEvents != (ptrLastNode->eventNumber+1) || lastEventNumber != ptrLastNode->eventNumber ) {
// // printf("\n");
// printf("(INVARIANTES) NUMERO ERRADO DE EVENTOS!!!\n");
// // printf("\n");
// }
//
// // testando o numero de chegadas e partidas de maquinas
// if (numberOfArrivals != numberOfDepartures) {
// // printf("\n");
// printf("(INVARIANTES) NUMERO DE CHEGADAS DIFERENTE DO NUMERO DE SAIDAS!!!\n");
// }
// // ##### FIM DAS INVARIANTES PARA A LISTA DE EVENTOS #####
// ##### INVARIANTES PARA A LISTA DE MAQUINAS (CHEGADAS E PARTIDAS) #####
ptrAuxMachine = machineList;
if (ptrAuxMachine != NULL) {
printf("\n");
printf("(INVARIANTES) LISTA NAO VAZIA DE MAQUINAS!!!\n");
count = 0;
while(ptrAuxMachine) {
count++;
printf("machineID %d source %d status %d AT %ld DT %ld UP %.2f RP %.2f\n", ptrAuxMachine->machineID,
ptrAuxMachine->source, ptrAuxMachine->status, ptrAuxMachine->arrivalTime, ptrAuxMachine->departureTime,
ptrAuxMachine->usagePrice, ptrAuxMachine->reservationPrice);
ptrAuxMachine = ptrAuxMachine->nextMachine;
}
printf("a lista tem %ld maquinas\n", count);
printf("\n");
}
// ##### FIM INVARIANTES PARA A LISTA DE MAQUINAS (CHEGADAS E PARTIDAS) #####
// // ##### INVARIANTES PARA A LISTA DE EXECUCAO DAS TASKS #####
// FILE *ptrFileTaskAccountInfo;
// ptrFileTaskAccountInfo = fopen("taskaccountinfo.txt", "a+");
// taskAccountInfo *ptrAuxTaskAccountInfo;
// ptrAuxTaskAccountInfo = taskAccountInfoList;
// unsigned long int totalExecutionTime = 0;
// while(ptrAuxTaskAccountInfo) {
//
// if (ptrAuxTaskAccountInfo->source == 1) {
// totalExecutionTime += (ptrAuxTaskAccountInfo->finnishTime-ptrAuxTaskAccountInfo->startTime);
// }
// if ( ptrAuxTaskAccountInfo->runtime < (ptrAuxTaskAccountInfo->finnishTime-ptrAuxTaskAccountInfo->startTime) ) {
// // printf("\n");
// printf("(INVARIANTES) TEMPO DE EXECUCAO MAIOR DO QUE O RUNTIME!!!\n");
// }
//
// if ( (ptrAuxTaskAccountInfo->finnishTime-ptrAuxTaskAccountInfo->startTime) < 0 ) {
// // printf("\n");
// printf("(INVARIANTES) FINNISHTIME MENOR DO QUE STARTTIME!!!\n");
// }
//
// fprintf(ptrFileTaskAccountInfo,"taskAccountID %d machineID %d source %d taskID %d jobID %d RT %d ET %ld ST %ld FT %ld Status %d Cost %.2f\n", ptrAuxTaskAccountInfo->taskAccountID,
// ptrAuxTaskAccountInfo->machineID, ptrAuxTaskAccountInfo->source, ptrAuxTaskAccountInfo->taskID, ptrAuxTaskAccountInfo->jobID,
// ptrAuxTaskAccountInfo->runtime, (ptrAuxTaskAccountInfo->finnishTime-ptrAuxTaskAccountInfo->startTime),
// ptrAuxTaskAccountInfo->startTime, ptrAuxTaskAccountInfo->finnishTime, ptrAuxTaskAccountInfo->status, ptrAuxTaskAccountInfo->cost);
//
// ptrAuxTaskAccountInfo = ptrAuxTaskAccountInfo->nextTaskAccountInfo;
// }
// // printf("a lista tem %d tasks\n", count);
// // printf("\n");
// fclose(ptrFileTaskAccountInfo);
// // ##### FIM INVARIANTES PARA A LISTA DE EXECUCAO DAS TASKS #####
// // ##### INVARIANTES PARA O CONSUMO DA GRADE E PARA BALANCO DE CREDITOS #####
// FILE *ptrFileGridAccountInfo;
// ptrFileGridAccountInfo = fopen("gridaccountinfo.txt", "a+");
// gridAccountInfo *ptrAuxGridInfo;
// ptrAuxGridInfo = gridInfoList;
// unsigned long int credit = 0;
// while(ptrAuxGridInfo) {
// credit += (ptrAuxGridInfo->finnishTime - ptrAuxGridInfo->startTime);
// fprintf(ptrFileGridAccountInfo, "gridAccountID %d machineID %d source %d ST %ld FT %ld\n", ptrAuxGridInfo->gridAccountID,
// ptrAuxGridInfo->machineID, ptrAuxGridInfo->source, ptrAuxGridInfo->startTime,
// ptrAuxGridInfo->finnishTime);
// ptrAuxGridInfo = ptrAuxGridInfo->nextGridAccountInfo;
// }
// // printf("a lista tem %d balances, e o total de creditos doados e %d\n", count, credit);
// // printf("\n");
// fclose(ptrFileGridAccountInfo);
//
// FILE *ptrFileBalanceAccountInfo;
// ptrFileBalanceAccountInfo = fopen("balanceaccountinfo.txt", "a+");
// balanceAccountInfo *ptrAuxBalanceAccountInfo;
// ptrAuxBalanceAccountInfo = balanceAccountInfoList;
// unsigned long int consumed = 0, lastValue = 0;
// while(ptrAuxBalanceAccountInfo->nextBalanceAccountInfo != NULL) {
//
// if (ptrAuxBalanceAccountInfo->consumed > lastValue) {
// consumed += lastValue;
// }
// else {
// consumed += ptrAuxBalanceAccountInfo->consumed;
// }
// lastValue = ptrAuxBalanceAccountInfo->value;
//
// fprintf(ptrFileBalanceAccountInfo, "balanceAccountID %ld time %ld consumed %ld value %ld\n", ptrAuxBalanceAccountInfo->balanceAccountID,
// ptrAuxBalanceAccountInfo->time, ptrAuxBalanceAccountInfo->consumed, ptrAuxBalanceAccountInfo->value);
//
// ptrAuxBalanceAccountInfo = ptrAuxBalanceAccountInfo->nextBalanceAccountInfo;
//
// }
// consumed += ptrAuxBalanceAccountInfo->consumed;
// fprintf(ptrFileBalanceAccountInfo, "balanceAccountID %ld time %ld consumed %ld value %ld\n", ptrAuxBalanceAccountInfo->balanceAccountID, ptrAuxBalanceAccountInfo->time,
// ptrAuxBalanceAccountInfo->consumed, ptrAuxBalanceAccountInfo->value);
// // printf("a lista de balances tem %d registros\n", count);
// // printf("\n");
// fclose(ptrFileBalanceAccountInfo);
//
// if ( credit != (ptrAuxBalanceAccountInfo->value + consumed) ) {
// // printf("\n");
// printf("(INVARIANTES) BALANCE DO GRID ERRADO!!!\n");
// printf("credit %ld (balance+consumed) %ld consumed %ld totalET %ld\n", credit, (ptrAuxBalanceAccountInfo->value + consumed), consumed, totalExecutionTime);
// }
// // printf("doado %d consumido %d balance %d\n", credit, consumed, ptrAuxBalanceAccountInfo->value);
// // ##### FIM INVARIANTES PARA O CONSUMO DA GRADE E PARA BALANCO DE CREDITOS #####
} else printf("ERROR (Main Simulator): invalid number of input parameters!!!\n");
time(&newEnd);
// second = CPU_TIME;
// printf("Opt Flag: %d Grid QoS-Factor: %.2f Simulation Period (days): %d Machines ([InH, Res, OnD]): [%d, %d, %d] Seed: %d UF: %d Time elapsed (seconds): %ld\n",
// optFlag, gridQoSFactor, (int)(simulationTime/1440), numberOfLocalMachines, numberOfReservedMachines, numberOfOnDemandMachines,
// simSeed, utilityFunction,(clock() - start) / CLOCKS_PER_SEC);
printf("SimMode: %d SimTime (days): %d JobSize: %d GridQoS: %.2f OnDPFactor: %.2f IhFactor: %.2f Machines ([InH, Res, OnD]): [%d, %d, %d] TaskAvg: %d "
"GridAvg: %d UF: %d Seed: %d #Events: %ld ExecTime (seconds): %ld AggUtility: %.2f AggCost %.2f AggProfit %.2f\n", optFlag, (int)(simulationTime/1440), jobSize, gridQoSFactor, ondemandPriceFactor,
inhouseFactor, numberOfLocalMachines, numberOfReservedMachines, numberOfOnDemandMachines, taskAvgTime, gridAvgUptime, utilityFunction, simSeed,
totalNumberOfEvents, (unsigned long int)(newEnd - newStart), aggregatedUtility, aggregatedCost, aggregatedProfit);
// event teste;
// printf("tamanho das estruturas: %d\n", sizeof(teste));
return EXIT_SUCCESS;
}
