//============================================================================== Time getLastMouseDownTime() const noexcept { return Time (mouseDowns[0].time); }
/// division operator Time Time::operator/ (double div) const { return Time(this->totalDays()/div); }
void TurretDataComponent::updateAutoCooldown(float secondsToAdd) { int milisecondsToAdd = secondsToAdd*1000; nextAutoFireTime = Time(); nextAutoFireTime.addMiliTime(milisecondsToAdd); }
void ReqLogin::ChooseMode() { TheResearchCalendar::Instance()->Clear(); GameMode gm = AMJU_MODE_NO_GAME; bool doCogTests = false; PXml research = m_xml.getChildNode(5); if (SafeStrCmp(research.getName(), "research")) { // Schedule - for calendar PXml p = research.getChildNode(4); if (SafeStrCmp(p.getName(), "dates")) { Time today(Time::Now()); today.RoundDown(TimePeriod(ONE_DAY_IN_SECONDS)); // Bunch of dates - add to TheResearchCal int numDates = p.nChildNode(); for (int i = 0; i < numDates; i++) { PXml date = p.getChildNode(i); if (SafeStrCmp(date.getName(), "date")) { if (SafeStrCmp(date.getChildNode(0).getName(), "timestamp") && SafeStrCmp(date.getChildNode(1).getName(), "cogtest") && SafeStrCmp(date.getChildNode(2).getName(), "play")) { std::string dateStr = date.getChildNode(0).getText(); bool cogtest = SafeStrCmp(date.getChildNode(1).getText(), "1"); bool play = SafeStrCmp(date.getChildNode(2).getText(), "1"); Time t(dateStr); t.RoundDown(TimePeriod(ONE_DAY_IN_SECONDS)); if (t == today) { // Cog tests already done today ? Results results = TheCogTestResults::Instance()->GetResultsForDate(Time::Now()); if (results.empty()) { doCogTests = cogtest; } else { doCogTests = false; std::cout << "Test results for today are here already.\n"; } if (play) { gm = AMJU_MODE_MULTI; } if (doCogTests && !play) { // Create dummy target for heart count, etc CreateDummyLocalPlayer(); } } TheResearchCalendar::Instance()->AddResearchDate(ResearchDate(Time(dateStr), cogtest, play)); } else { std::cout << "Login: unexpected format for session dates.\n"; Assert(0); } } } } else { std::cout << "Login: found research element but no schedule.\n"; } } else { std::cout << "No research element in login.pl response?!?\n"; Assert(0); } // Now we can look up today on the calendar to get game mode flags. ResetLocalPlayerFuelCount(); SetGameMode(gm); // TODO handle edit mode - send extra flag to login.pl ?? SetDoCogTests(doCogTests); // mode, in GameMode TheGSCalendar::Instance()->SetPrevState(TheGSToday::Instance()); TheGSThanks::Instance()->SetPrevState(TheGSToday::Instance()); TheGame::Instance()->SetCurrentState(TheGSThanks::Instance()); TheGSMain::Instance()->ResetHud(); }
void prompt_code(){ Putc(COM1, 96); // GO command for trains Create(PR_TIMER, timer_code); int dfa_tid = Create(PR_DFA, dfa_code); int train_tid = Create(PR_TRAIN_COMMANDER, train_commander_code); int switch_tid = Create(PR_SWITCH, switch_code); Create(PR_SENSOR, sensor_code); char input, state; char buff[9]; train_server_request tsr; int node_index = 0; while (1){ input = Getc(COM2); if (input == 'q'){ Putc(COM1, 97); // Stop command for trains Putc(COM2, input); // ECHO Printf(COM2, " ");Printf(COM2, " ");Printf(COM2, " "); // send signal to calibration server to print calibration data and halt the system. // Send(WhoIs("CALIBRATIONSERVER"), &input, sizeof(char), &input, sizeof(char)); SHUTDOWN(); // CALL SHUTDOWN SYSCALL to shutdown the program } else if (input == '/'){ Debug("[Time: %d ]", Time()); continue; } Send(dfa_tid, &input, sizeof(char), &buff, 9*sizeof(char)); state = buff[0]; switch (state){ case DFA_FULL: Printf(COM2, "\033[s\033[%d;%dHPrompt is full! \033[u", CMD_OUT_ROW, CMD_OUT_COL); break; case DFA_INVALID: Printf(COM2, "\033[%d;%dHInvalid input!!! \033[%d;%dH", CMD_OUT_ROW, CMD_OUT_COL, CMD_ROW, CMD_COL); Printf(COM2, "\033[%d;%dH\033[s \033[u", CMD_ROW, CMD_COL); break; case DFA_OK: Putc(COM2, input); // ECHO break; case DFA_BACKSPACE: Printf(COM2, "%c %c", input, input); // Echo break; case DFA_NO_BACKSPACE: Printf(COM2, "\033[s\033[%d;%dH \033[u", CMD_OUT_ROW, CMD_OUT_COL); break; case DFA_TR_SP: Printf(COM2, "\033[s\033[%d;%dHSetting speed of tr#%d to %d... \033[u", CMD_OUT_ROW, CMD_OUT_COL, buff[2], buff[1]); Printf(COM2, "\033[%d;%dH\033[s \033[u", CMD_ROW, CMD_COL); // Send command to the train task to set speed of the train Send(train_tid, buff+1, 2*sizeof(char), &input, sizeof(char)); break; case DFA_TR_SP_AT_NODE: Printf(COM2, "\033[s\033[%d;%dHSetting speed of tr#%d to %d at node %s...\033[u", CMD_OUT_ROW, CMD_OUT_COL, buff[2], buff[1], (buff+3)); Printf(COM2, "\033[%d;%dH\033[s \033[u", CMD_ROW, CMD_COL); tsr.type = TRAIN_TYPE_SPEED_AT_NODE; tsr.data.speed_request.speed = buff[1]; tsr.data.speed_request.tr_num = buff[2]; strncpy(tsr.data.speed_request.node_name, buff+3, 6); Send(WhoIs("TRAINSERVER"), &tsr, sizeof(train_server_request), &input, sizeof(char)); break; case DFA_TR_RV: Printf(COM2, "\033[s\033[%d;%dHReversing tr#%d... \033[u", CMD_OUT_ROW, CMD_OUT_COL, buff[2]); Printf(COM2, "\033[%d;%dH\033[s \033[u", CMD_ROW, CMD_COL); buff[1] = 15; Send(train_tid, buff+1, 2*sizeof(char), &input, sizeof(char)); break; case DFA_SW: Printf(COM2, "\033[s\033[%d;%dHThrowing sw#%d to %c... \033[u", CMD_OUT_ROW, CMD_OUT_COL, buff[2], buff[1]); Printf(COM2, "\033[%d;%dH\033[s \033[u", CMD_ROW, CMD_COL); Send(switch_tid, buff+1, 2*sizeof(char), &input, sizeof(char)); break; case DFA_STOP_AT: Printf(COM2, "\033[s\033[%d;%dHStopping train %d at %s \033[u", CMD_OUT_ROW, CMD_OUT_COL, buff[2], (buff+3)); Printf(COM2, "\033[%d;%dH\033[s \033[u", CMD_ROW, CMD_COL); // Send appropriate command to train server to stop the train at the appropriate location tsr.type = TRAIN_TYPE_SPEED_AT_NODE; tsr.data.speed_request.speed = buff[1]; tsr.data.speed_request.tr_num = buff[2]; strncpy(tsr.data.speed_request.node_name, buff+3, 6); Send(WhoIs("TRAINSERVER"), &tsr, sizeof(train_server_request), &input, sizeof(char)); break; case DFA_GO_TO: tsr.type = TRAIN_TYPE_GO_TO_NODE; tsr.data.speed_request.tr_num = buff[2]; strncpy(tsr.data.speed_request.node_name, buff+3, 6); Send(WhoIs("TRAINSERVER"), &tsr, sizeof(train_server_request), &node_index, sizeof(int)); if(node_index != -1) { Printf(COM2, "\033[s\033[%d;%dHMoving train %d to %s \033[u", CMD_OUT_ROW, CMD_OUT_COL, buff[2], (buff+3)); Printf(COM2, "\033[%d;%dH\033[s \033[u", CMD_ROW, CMD_COL); } else { Printf(COM2, "\033[s\033[%d;%dHInvalid node name \033[u", CMD_OUT_ROW, CMD_OUT_COL); Printf(COM2, "\033[%d;%dH\033[s \033[u", CMD_ROW, CMD_COL); } break; case DFA_SW_ALL_C: Printf(COM2, "\033[s\033[%d;%dHInitializing switches to C (curve)... \033[u", CMD_OUT_ROW, CMD_OUT_COL); Printf(COM2, "\033[%d;%dH\033[s \033[u", CMD_ROW, CMD_COL); buff[2] = SWICTH_ALL_C; Send(switch_tid, buff+1, 2*sizeof(char), &input, sizeof(char)); break; case DFA_SW_ALL_S: Printf(COM2, "\033[s\033[%d;%dHInitializing switches to S (straight)... \033[u", CMD_OUT_ROW, CMD_OUT_COL); Printf(COM2, "\033[%d;%dH\033[s \033[u", CMD_ROW, CMD_COL); buff[2] = SWICTH_ALL_S; Send(switch_tid, buff+1, 2*sizeof(char), &input, sizeof(char)); break; case DFA_SW_SMALL_LOOP1: Printf(COM2, "\033[s\033[%d;%dHInitializing switches to small loop 1... \033[u", CMD_OUT_ROW, CMD_OUT_COL); Printf(COM2, "\033[%d;%dH\033[s \033[u", CMD_ROW, CMD_COL); buff[2] = SWICTH_SMALL_LOOP1; Send(switch_tid, buff+1, 2*sizeof(char), &input, sizeof(char)); break; case DFA_SW_SMALL_LOOP2: Printf(COM2, "\033[s\033[%d;%dHInitializing switches to small loop 2... \033[u", CMD_OUT_ROW, CMD_OUT_COL); Printf(COM2, "\033[%d;%dH\033[s \033[u", CMD_ROW, CMD_COL); buff[2] = SWICTH_SMALL_LOOP2; Send(switch_tid, buff+1, 2*sizeof(char), &input, sizeof(char)); break; case DFA_SW_MEDIUM_LOOP: Printf(COM2, "\033[s\033[%d;%dHInitializing switches to medium loop... \033[u", CMD_OUT_ROW, CMD_OUT_COL); Printf(COM2, "\033[%d;%dH\033[s \033[u", CMD_ROW, CMD_COL); buff[2] = SWICTH_MEDIUM_LOOP; Send(switch_tid, buff+1, 2*sizeof(char), &input, sizeof(char)); break; case DFA_SW_LARGE_LOOP: Printf(COM2, "\033[s\033[%d;%dHInitializing switches to large loop... \033[u", CMD_OUT_ROW, CMD_OUT_COL); Printf(COM2, "\033[%d;%dH\033[s \033[u", CMD_ROW, CMD_COL); buff[2] = SWICTH_LARGE_LOOP; Send(switch_tid, buff+1, 2*sizeof(char), &input, sizeof(char)); break; case DFA_SW_EXTRA_LARGE_LOOP: Printf(COM2, "\033[s\033[%d;%dHInitializing switches to extra large loop \033[u", CMD_OUT_ROW, CMD_OUT_COL); Printf(COM2, "\033[%d;%dH\033[s \033[u", CMD_ROW, CMD_COL); buff[2] = SWICTH_EXTRA_LARGE_LOOP; Send(switch_tid, buff+1, 2*sizeof(char), &input, sizeof(char)); break; case DFA_SW_DEFAULT: Printf(COM2, "\033[s\033[%d;%dHInitializing switches to default state... \033[u", CMD_OUT_ROW, CMD_OUT_COL); Printf(COM2, "\033[%d;%dH\033[s \033[u", CMD_ROW, CMD_COL); buff[2] = SWICTH_DEFAULT; Send(switch_tid, buff+1, 2*sizeof(char), &input, sizeof(char));break; break; default: Printf(COM2, "\033[s\033[%d;%dHDFA PROBLEM!!! \033[u", CMD_OUT_ROW, CMD_OUT_COL); Printf(COM2, "\033[%d;%dH\033[s \033[u", CMD_ROW, CMD_COL); break; } } Warning(0,"Unexpected return from Exit() at prompt_code\n\r"); Exit(); Warning(0,"Unexpected return from Exit() at prompt_code\n\r"); }
int main(int argc, char** argv) { if (argc != 3) { fprintf(stderr, "usage: %s i2c-dev i2c-slave-number\n", argv[0]); exit(1); } const char* bus = argv[1]; char* err; int dev = strtol(argv[2], &err, 10); if(!*argv[2] || *err) { fprintf(stderr, "usage: %s <i2c-dev> <i2c-slave-number>\n", argv[0]); fprintf(stderr, " i2c-slave-number must be a number\n"); exit(1); } WebServiceFSM wsfsm{"http://localhost:8080/"}; RealProtocolFSM pfsm; pfsm.init(bus, dev); joystickInit(); uint8_t id = 0; // ProtocolState old_state = pfsm.state; while(true) { js_state state; joystickState(&state); wsfsm.update(); pfsm.update(); /* DEBUGGING if(pfsm.state != old_state) { fprintf(stderr, "PFSM: %s => %s\n", ProtocolStateStr[old_state], ProtocolStateStr[pfsm.state]); old_state = pfsm.state; } */ Message msg; // can we send another message? if(pfsm.state == IDLE) { double speed_value = 0.0; double angle_value = 0.0; if(Time() - lastJoystickUpdate() < TimeLength::inSeconds(1)) { speed_value = (static_cast<double>(state.axis[1])) * (33.0 / 32767.0); angle_value = (static_cast<double>(state.axis[0])) * (-30.0 / 32767.0); // deadzones if(speed_value > -5 && speed_value < 5) { speed_value = 0; } if(angle_value > -2 && angle_value < 2) { angle_value = 0; } } else if (wsfsm.command_available) { speed_value = wsfsm.command.speed * 33.0; angle_value = std::max(-30.0, std::min(30.0, wsfsm.command.angle*-1.0)); wsfsm.command_completed = true; } int8_t speed_ival = static_cast<int8_t>(speed_value); int8_t angle_ival = static_cast<int8_t>(angle_value); //printf("speed = %f, %d angle = %f, %d\n", speed_value, speed_ival, angle_value, angle_ival); messageSignedInit(&msg, COMMAND_SET_MOTION, speed_ival, angle_ival, id++); pfsm.send(&msg); } if(pfsm.state == SENDING_FAILED || pfsm.state == ACKING_FAILED) { // don't care for now fprintf(stderr, "ignorning error\n"); pfsm.clearError(); messageSignedInit(&msg, COMMAND_SET_MOTION, speed_ival, angle_ival, id++); pfsm.send(&msg); // webservice: will be implemented in wsfsm.cpp later } if(pfsm.state == ACK_COMPLETE) { pfsm.acknowledgeAck(); } // sleep off any delay the protocol is waiting for because we have // nothing better to do right now - imp. b/c running on battery TimeLength delay = pfsm.delayRemaining(); if(delay > TimeLength::inSeconds(0)) { usleep(delay.microseconds()); } } return (EXIT_SUCCESS); }
time_t CTimer::RetryTime(void) { return Time() + (m_ReasonableRefreshDelay>0?m_ReasonableRefreshDelay:24*60*60); /* 24 hours */ }
void ComplexStatsWin::refresh() { Time f; // from Time t; // to switch ( (En_stats_interval)((int)interval.GetData()) ) { case siDay: { Date d = day_date.GetData(); f = ToTime(d); t = Time(d.year, d.month, d.day, 23, 59, 59); break; } case siMonth: { Date from = FirstDayOfMonth(month_date.GetData()); Date to = LastDayOfMonth(month_date.GetData()); f = Time(from.year, from.month, from.day, 0, 0, 0); t = Time(to.year, to.month, to.day, 23, 59, 59); break; } case siDateRange: { Date from = date_from.GetData(); Date to = date_to.GetData(); f = Time(from.year, from.month, from.day, 0, 0, 0); t = Time(to.year, to.month, to.day, 23, 59, 59); } }; //record count SQL & Select(SqlCountRows()).From(RECORD).Where(REC_DATE >= f && REC_DATE <= t); if (SQL.Fetch()) record_count.SetText(~AsString(SQL[0])); //income SQL & Select(SqlSum(ITEM_PRICE)) .From(RECORD_ITEM) .InnerJoin(RECORD).On(RECORD_ID.Of(RECORD_ITEM) == ID.Of(RECORD)) .Where(REC_DATE.Of(RECORD) >= f && REC_DATE.Of(RECORD) <= t) ; if (SQL.Fetch()) { String s = ConvertMoney().Format(SQL[0]); income.SetText(~s); } //income from invoices only SQL & Select(SqlSum(ITEM_PRICE)) .From(RECORD_ITEM) .InnerJoin(RECORD).On(RECORD_ID.Of(RECORD_ITEM) == ID.Of(RECORD)) .Where(REC_DATE.Of(RECORD) >= f && REC_DATE.Of(RECORD) <= t && NotNull(INVOICE_ID.Of(RECORD))) ; if (SQL.Fetch()) { String s = ConvertMoney().Format(SQL[0]); income_inv.SetText(~s); } //income without invoices SQL & Select(SqlSum(ITEM_PRICE)) .From(RECORD_ITEM) .InnerJoin(RECORD).On(RECORD_ID.Of(RECORD_ITEM) == ID.Of(RECORD)) .Where(REC_DATE.Of(RECORD) >= f && REC_DATE.Of(RECORD) <= t && IsNull(INVOICE_ID.Of(RECORD))) ; if (SQL.Fetch()) { String s = ConvertMoney().Format(SQL[0]); income_noinv.SetText(~s); } //products products.Clear(); SQL & Select(NAME.Of(LOV_PRODUCT), Count(LOV_PRODUCT)) .From(RECORD_ITEM) .InnerJoin(LOV_PRODUCT).On(PROD_ID.Of(RECORD_ITEM) == ID.Of(LOV_PRODUCT)) .InnerJoin(RECORD).On(RECORD_ID.Of(RECORD_ITEM) == ID.Of(RECORD)) .Where(REC_DATE.Of(RECORD) >= f && REC_DATE.Of(RECORD) <= t) .GroupBy(NAME.Of(LOV_PRODUCT)) .OrderBy(Descending(Count(LOV_PRODUCT))) ; while(SQL.Fetch()) products.Add(SQL); //clients unsigned c = 0; clients.Clear(); SQL & Select(NAME.Of(LOV_TITLE), FIRST_NAME.Of(CLIENT), LAST_NAME.Of(CLIENT)) .From(RECORD) .InnerJoin(PATIENT).On(PATIENT_ID.Of(RECORD) == ID.Of(PATIENT)) .InnerJoin(CLIENT).On(CLIENT_ID.Of(PATIENT) == ID.Of(CLIENT)) .LeftJoin(LOV_TITLE).On(TITLE_ID.Of(CLIENT) == ID.Of(LOV_TITLE)) .Where(REC_DATE.Of(RECORD) >= f && REC_DATE.Of(RECORD) <= t) .OrderBy(REC_DATE.Of(RECORD)) ; while(SQL.Fetch() && ++c) clients.Add(SQL); client_count.SetText(AsString(c)); }
Time GetUtcTime() { SYSTEMTIME st; GetSystemTime(&st); return Time(st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond); }
void nest::SimulationManager::update_() { // to store done values of the different threads std::vector< bool > done; bool done_all = true; delay old_to_step; exit_on_user_signal_ = false; std::vector< lockPTR< WrappedThreadException > > exceptions_raised( kernel().vp_manager.get_num_threads() ); bool exception_raised = false; // none raised on any thread // parallel section begins #pragma omp parallel { const int thrd = kernel().vp_manager.get_thread_id(); do { if ( print_time_ ) { gettimeofday( &t_slice_begin_, NULL ); } if ( kernel().sp_manager.is_structural_plasticity_enabled() && ( clock_.get_steps() + from_step_ ) % kernel().sp_manager.get_structural_plasticity_update_interval() == 0 ) { for ( std::vector< Node* >::const_iterator i = kernel().node_manager.get_nodes_on_thread( thrd ).begin(); i != kernel().node_manager.get_nodes_on_thread( thrd ).end(); ++i ) { ( *i )->update_synaptic_elements( Time( Time::step( clock_.get_steps() + from_step_ ) ).get_ms() ); } #pragma omp barrier #pragma omp single { kernel().sp_manager.update_structural_plasticity(); } // Remove 10% of the vacant elements for ( std::vector< Node* >::const_iterator i = kernel().node_manager.get_nodes_on_thread( thrd ).begin(); i != kernel().node_manager.get_nodes_on_thread( thrd ).end(); ++i ) { ( *i )->decay_synaptic_elements_vacant(); } } if ( from_step_ == 0 ) // deliver only at beginning of slice { kernel().event_delivery_manager.deliver_events( thrd ); #ifdef HAVE_MUSIC // advance the time of music by one step (min_delay * h) must // be done after deliver_events_() since it calls // music_event_out_proxy::handle(), which hands the spikes over to // MUSIC *before* MUSIC time is advanced // wait until all threads are done -> synchronize #pragma omp barrier // the following block is executed by the master thread only // the other threads are enforced to wait at the end of the block #pragma omp master { // advance the time of music by one step (min_delay * h) must // be done after deliver_events_() since it calls // music_event_out_proxy::handle(), which hands the spikes over to // MUSIC *before* MUSIC time is advanced if ( slice_ > 0 ) { kernel().music_manager.advance_music_time(); } // the following could be made thread-safe kernel().music_manager.update_music_event_handlers( clock_, from_step_, to_step_ ); } // end of master section, all threads have to synchronize at this point #pragma omp barrier #endif } // preliminary update of nodes that use waveform relaxtion if ( kernel().node_manager.wfr_is_used() ) { #pragma omp single { // if the end of the simulation is in the middle // of a min_delay_ step, we need to make a complete // step in the wfr_update and only do // the partial step in the final update // needs to be done in omp single since to_step_ is a scheduler // variable old_to_step = to_step_; if ( to_step_ < kernel().connection_manager.get_min_delay() ) { to_step_ = kernel().connection_manager.get_min_delay(); } } bool max_iterations_reached = true; const std::vector< Node* >& thread_local_wfr_nodes = kernel().node_manager.get_wfr_nodes_on_thread( thrd ); for ( long n = 0; n < wfr_max_iterations_; ++n ) { bool done_p = true; // this loop may be empty for those threads // that do not have any nodes requiring wfr_update for ( std::vector< Node* >::const_iterator i = thread_local_wfr_nodes.begin(); i != thread_local_wfr_nodes.end(); ++i ) { done_p = wfr_update_( *i ) && done_p; } // add done value of thread p to done vector #pragma omp critical done.push_back( done_p ); // parallel section ends, wait until all threads are done -> synchronize #pragma omp barrier // the following block is executed by a single thread // the other threads wait at the end of the block #pragma omp single { // set done_all for ( size_t i = 0; i < done.size(); i++ ) { done_all = done[ i ] && done_all; } // gather SecondaryEvents (e.g. GapJunctionEvents) kernel().event_delivery_manager.gather_events( done_all ); // reset done and done_all //(needs to be in the single threaded part) done_all = true; done.clear(); } // deliver SecondaryEvents generated during wfr_update // returns the done value over all threads done_p = kernel().event_delivery_manager.deliver_events( thrd ); if ( done_p ) { max_iterations_reached = false; break; } } // of for (wfr_max_iterations) ... #pragma omp single { to_step_ = old_to_step; if ( max_iterations_reached ) { std::string msg = String::compose( "Maximum number of iterations reached at interval %1-%2 ms", clock_.get_ms(), clock_.get_ms() + to_step_ * Time::get_resolution().get_ms() ); LOG( M_WARNING, "SimulationManager::wfr_update", msg ); } } } // of if(wfr_is_used) // end of preliminary update const std::vector< Node* >& thread_local_nodes = kernel().node_manager.get_nodes_on_thread( thrd ); for ( std::vector< Node* >::const_iterator node = thread_local_nodes.begin(); node != thread_local_nodes.end(); ++node ) { // We update in a parallel region. Therefore, we need to catch // exceptions here and then handle them after the parallel region. try { if ( not( *node )->is_frozen() ) { ( *node )->update( clock_, from_step_, to_step_ ); } } catch ( std::exception& e ) { // so throw the exception after parallel region exceptions_raised.at( thrd ) = lockPTR< WrappedThreadException >( new WrappedThreadException( e ) ); } } // parallel section ends, wait until all threads are done -> synchronize #pragma omp barrier // the following block is executed by the master thread only // the other threads are enforced to wait at the end of the block #pragma omp master { // check if any thread in parallel section raised an exception for ( index thrd = 0; thrd < kernel().vp_manager.get_num_threads(); ++thrd ) { if ( exceptions_raised.at( thrd ).valid() ) { exception_raised = true; break; } } // gather only at end of slice if ( to_step_ == kernel().connection_manager.get_min_delay() ) { kernel().event_delivery_manager.gather_events( true ); } advance_time_(); if ( SLIsignalflag != 0 ) { LOG( M_INFO, "SimulationManager::update", "Simulation exiting on user signal." ); exit_on_user_signal_ = true; } if ( print_time_ ) { gettimeofday( &t_slice_end_, NULL ); print_progress_(); } } // end of master section, all threads have to synchronize at this point #pragma omp barrier } while ( to_do_ > 0 and not exit_on_user_signal_ and not exception_raised ); // End of the slice, we update the number of synaptic elements for ( std::vector< Node* >::const_iterator i = kernel().node_manager.get_nodes_on_thread( thrd ).begin(); i != kernel().node_manager.get_nodes_on_thread( thrd ).end(); ++i ) { ( *i )->update_synaptic_elements( Time( Time::step( clock_.get_steps() + to_step_ ) ).get_ms() ); } } // end of #pragma parallel omp // check if any exceptions have been raised for ( index thrd = 0; thrd < kernel().vp_manager.get_num_threads(); ++thrd ) { if ( exceptions_raised.at( thrd ).valid() ) { simulating_ = false; // must mark this here, see #311 inconsistent_state_ = true; throw WrappedThreadException( *( exceptions_raised.at( thrd ) ) ); } } }
bool PlayerCreationManager::createCharacter(ClientCreateCharacterCallback* callback) { TemplateManager* templateManager = TemplateManager::instance(); ZoneClientSession* client = callback->getClient(); if (client->getCharacterCount(zoneServer.get()->getGalaxyID()) >= 10) { ErrorMessage* errMsg = new ErrorMessage("Create Error", "You are limited to 10 characters per galaxy.", 0x0); client->sendMessage(errMsg); return false; } PlayerManager* playerManager = zoneServer.get()->getPlayerManager(); SkillManager* skillManager = SkillManager::instance(); //Get all the data and validate it. UnicodeString characterName; callback->getCharacterName(characterName); //TODO: Replace this at some point? if (!playerManager->checkPlayerName(callback)) return false; String raceFile; callback->getRaceFile(raceFile); uint32 serverObjectCRC = raceFile.hashCode(); PlayerCreatureTemplate* playerTemplate = dynamic_cast<PlayerCreatureTemplate*>(templateManager->getTemplate( serverObjectCRC)); if (playerTemplate == NULL) { error("Unknown player template selected: " + raceFile); return false; } String fileName = playerTemplate->getTemplateFileName(); String clientTemplate = templateManager->getTemplateFile( playerTemplate->getClientObjectCRC()); RacialCreationData* raceData = racialCreationData.get(fileName); if (raceData == NULL) raceData = racialCreationData.get(0); //Just get the first race, since they tried to create a race that doesn't exist. String profession, customization, hairTemplate, hairCustomization; callback->getSkill(profession); if (profession.contains("jedi")) profession = "crafting_artisan"; callback->getCustomizationString(customization); callback->getHairObject(hairTemplate); callback->getHairCustomization(hairCustomization); float height = callback->getHeight(); height = MAX(MIN(height, playerTemplate->getMaxScale()), playerTemplate->getMinScale()); //validate biography UnicodeString bio; callback->getBiography(bio); bool doTutorial = callback->getTutorialFlag(); //bool doTutorial = false; ManagedReference<CreatureObject*> playerCreature = zoneServer.get()->createObject( serverObjectCRC, 2).castTo<CreatureObject*>(); if (playerCreature == NULL) { error("Could not create player with template: " + raceFile); return false; } Locker playerLocker(playerCreature); playerCreature->createChildObjects(); playerCreature->setHeight(height); playerCreature->setCustomObjectName(characterName, false); //TODO: Validate with Name Manager. client->setPlayer(playerCreature); playerCreature->setClient(client); // Set starting cash and starting bank playerCreature->setCashCredits(startingCash, false); playerCreature->setBankCredits(startingBank, false); ManagedReference<PlayerObject*> ghost = playerCreature->getPlayerObject(); if (ghost != NULL) { //Set skillpoints before adding any skills. ghost->setSkillPoints(skillPoints); ghost->setStarterProfession(profession); } addCustomization(playerCreature, customization, playerTemplate->getAppearanceFilename()); addHair(playerCreature, hairTemplate, hairCustomization); if (!doTutorial) { addProfessionStartingItems(playerCreature, profession, clientTemplate, false); addStartingItems(playerCreature, clientTemplate, false); addRacialMods(playerCreature, fileName, playerTemplate->getStartingSkills(), playerTemplate->getStartingItems(), false); } else { addProfessionStartingItems(playerCreature, profession, clientTemplate, true); addStartingItems(playerCreature, clientTemplate, true); addRacialMods(playerCreature, fileName, playerTemplate->getStartingSkills(), playerTemplate->getStartingItems(), true); } // Set starting cash and starting bank playerCreature->setCashCredits(startingCash, false); playerCreature->setBankCredits(startingBank, false); if (ghost != NULL) { ghost->setAccountID(client->getAccountID()); if (!freeGodMode) { try { uint32 accID = client->getAccountID(); ManagedReference<Account*> playerAccount = playerManager->getAccount(accID); if (playerAccount == NULL) { playerCreature->destroyPlayerCreatureFromDatabase(true); return false; } int accountPermissionLevel = playerAccount->getAdminLevel(); String accountName = playerAccount->getUsername(); if(accountPermissionLevel > 0 && (accountPermissionLevel == 9 || accountPermissionLevel == 10 || accountPermissionLevel == 12 || accountPermissionLevel == 15)) { playerManager->updatePermissionLevel(playerCreature, accountPermissionLevel); /* Reference<ShipControlDevice*> shipControlDevice = zoneServer->createObject(STRING_HASHCODE("object/intangible/ship/sorosuub_space_yacht_pcd.iff"), 1).castTo<ShipControlDevice*>(); //ShipObject* ship = (ShipObject*) server->createObject(STRING_HASHCODE("object/ship/player/player_sorosuub_space_yacht.iff"), 1); Reference<ShipObject*> ship = zoneServer->createObject(STRING_HASHCODE("object/ship/player/player_basic_tiefighter.iff"), 1).castTo<ShipObject*>(); shipControlDevice->setControlledObject(ship); if (!shipControlDevice->transferObject(ship, 4)) info("Adding of ship to device failed"); ManagedReference<SceneObject*> datapad = playerCreature->getSlottedObject("datapad"); if (datapad != NULL) { if (!datapad->transferObject(shipControlDevice, -1)) { shipControlDevice->destroyObjectFromDatabase(true); } } else { shipControlDevice->destroyObjectFromDatabase(true); error("could not get datapad from player"); } */ } if (accountPermissionLevel < 9) { try { StringBuffer query; //query << "SELECT UNIX_TIMESTAMP(creation_date) FROM characters c WHERE galaxy_id = " << zoneServer.get()->getGalaxyID() << " AND account_id = " << client->getAccountID() << " ORDER BY creation_date desc;"; uint32 galaxyId = zoneServer.get()->getGalaxyID(); uint32 accountId = client->getAccountID(); query << "(SELECT UNIX_TIMESTAMP(c.creation_date) as t FROM characters as c WHERE c.account_id = " << accountId << " AND c.galaxy_id = " << galaxyId << " ORDER BY c.creation_date DESC) UNION (SELECT UNIX_TIMESTAMP(d.creation_date) FROM deleted_characters as d WHERE d.account_id = " << accountId << " AND d.galaxy_id = " << galaxyId << " ORDER BY d.creation_date DESC) ORDER BY t DESC LIMIT 1"; Reference<ResultSet*> res = ServerDatabase::instance()->executeQuery(query); if (res != NULL && res->next()) { uint32 sec = res->getUnsignedInt(0); Time timeVal(sec); if (timeVal.miliDifference() < 3600000) { ErrorMessage* errMsg = new ErrorMessage("Create Error", "You are only permitted to create one character per hour. Repeat attempts prior to 1 hour elapsing will reset the timer.", 0x0); client->sendMessage(errMsg); playerCreature->destroyPlayerCreatureFromDatabase(true); return false; } //timeVal.se } } catch (DatabaseException& e) { error(e.getMessage()); } Locker locker(&charCountMutex); if (lastCreatedCharacter.containsKey(accID)) { Time lastCreatedTime = lastCreatedCharacter.get(accID); if (lastCreatedTime.miliDifference() < 3600000) { ErrorMessage* errMsg = new ErrorMessage("Create Error", "You are only permitted to create one character per hour. Repeat attempts prior to 1 hour elapsing will reset the timer.", 0x0); client->sendMessage(errMsg); playerCreature->destroyPlayerCreatureFromDatabase(true); return false; } else { lastCreatedTime.updateToCurrentTime(); lastCreatedCharacter.put(accID, lastCreatedTime); } } else { lastCreatedCharacter.put(accID, Time()); } } } catch (Exception& e) { error(e.getMessage()); } } else { playerManager->updatePermissionLevel(playerCreature, PermissionLevelList::instance()->getLevelNumber("admin")); } if (doTutorial) playerManager->createTutorialBuilding(playerCreature); else playerManager->createSkippedTutorialBuilding(playerCreature); ValidatedPosition* lastValidatedPosition = ghost->getLastValidatedPosition(); lastValidatedPosition->update(playerCreature); ghost->setBiography(bio); ghost->setLanguageID(playerTemplate->getDefaultLanguage()); } ClientCreateCharacterSuccess* msg = new ClientCreateCharacterSuccess( playerCreature->getObjectID()); playerCreature->sendMessage(msg); ChatManager* chatManager = zoneServer.get()->getChatManager(); chatManager->addPlayer(playerCreature); String firstName = playerCreature->getFirstName(); String lastName = playerCreature->getLastName(); int raceID = playerTemplate->getRace(); try { StringBuffer query; query << "INSERT INTO `characters_dirty` (`character_oid`, `account_id`, `galaxy_id`, `firstname`, `surname`, `race`, `gender`, `template`)" << " VALUES (" << playerCreature->getObjectID() << "," << client->getAccountID() << "," << zoneServer.get()->getGalaxyID() << "," << "'" << firstName.escapeString() << "','" << lastName.escapeString() << "'," << raceID << "," << 0 << ",'" << raceFile.escapeString() << "')"; ServerDatabase::instance()->executeStatement(query); } catch (DatabaseException& e) { error(e.getMessage()); } playerManager->addPlayer(playerCreature); // Copy claimed veteran rewards from player's alt character uint32 accID = client->getAccountID(); ManagedReference<Account*> playerAccount = playerManager->getAccount(accID); if (playerAccount != NULL && ghost != NULL) { // Find the first alt character ManagedReference<CreatureObject*> altPlayer = NULL; CharacterList* characters = playerAccount->getCharacterList(); for(int i = 0; i < characters->size(); ++i) { CharacterListEntry* entry = &characters->get(i); if(entry->getGalaxyID() == zoneServer.get()->getGalaxyID() && entry->getFirstName() != playerCreature->getFirstName() ) { altPlayer = playerManager->getPlayer(entry->getFirstName()); if( altPlayer != NULL ){ break; } } } // Record the rewards if alt player was found if( altPlayer != NULL && altPlayer->getPlayerObject() != NULL){ Locker alocker( altPlayer ); for( int i = 0; i < playerManager->getNumVeteranRewardMilestones(); i++ ){ int milestone = playerManager->getVeteranRewardMilestone(i); String claimedReward = altPlayer->getPlayerObject()->getChosenVeteranReward(milestone); if( !claimedReward.isEmpty() ){ ghost->addChosenVeteranReward(milestone,claimedReward); } } } } client->addCharacter(playerCreature->getObjectID(), zoneServer.get()->getGalaxyID()); JediManager::instance()->onPlayerCreated(playerCreature); chatManager->sendMail("system", "@newbie_tutorial/newbie_mail:welcome_subject", "@newbie_tutorial/newbie_mail:welcome_body", playerCreature->getFirstName()); //Join auction chat room ghost->addChatRoom(chatManager->getAuctionRoom()->getRoomID()); ManagedReference<SuiMessageBox*> box = new SuiMessageBox(playerCreature, SuiWindowType::NONE); box->setPromptTitle("PLEASE NOTE"); box->setPromptText("You are limited to creating one character per hour. Attempting to create another character or deleting your character before the 1 hour timer expires will reset the timer."); ghost->addSuiBox(box); playerCreature->sendMessage(box->generateMessage()); return true; }
bool CSubprocess::PSExtract(CSubprocess::PInfoArray &arPinfo) { bool rc=false; arPinfo.clear(); // If Windows NT: switch(GetPlatform()) { case VER_PLATFORM_WIN32_NT: if(hInstLib1) { // Get procedure addresses. static BOOL (WINAPI *lpfEnumProcesses)( DWORD *, DWORD cb, DWORD * ) = (BOOL(WINAPI *)(DWORD *,DWORD,DWORD*))GetProcAddress( hInstLib1, "EnumProcesses" ) ; if( lpfEnumProcesses) { if(hInstLib2) { static DWORD (WINAPI *lpfNtQueryInformationProcess)( HANDLE, int, void *, DWORD, LPDWORD ) = (DWORD(WINAPI *)(HANDLE, int, void *, DWORD, LPDWORD)) GetProcAddress( hInstLib2,"NtQueryInformationProcess" ) ; if(lpfNtQueryInformationProcess){ DWORD dwMaxPids=256; DWORD dwPidSize; DWORD *arPids = NULL ; do { delete [] arPids; arPids=new DWORD[dwMaxPids]; } while(lpfEnumProcesses(arPids, dwMaxPids, &dwPidSize) && dwPidSize/sizeof(DWORD)==dwMaxPids) ; if(dwPidSize/sizeof(DWORD)<dwMaxPids){ rc=true; for( DWORD dwIndex = 0 ; dwIndex < dwPidSize/sizeof(DWORD); dwIndex++ ) { // Regardless of OpenProcess success or failure, we // still call the enum func with the ProcID. DWORD pid=arPids[dwIndex]; HANDLE hProcess=::OpenProcess( PROCESS_QUERY_INFORMATION, FALSE, pid ); if (hProcess ) { struct { DWORD ExitStatus; // receives process termination status DWORD PebBaseAddress; // receives process environment block address DWORD AffinityMask; // receives process affinity mask DWORD BasePriority; // receives process priority class ULONG UniqueProcessId; // receives process identifier ULONG InheritedFromUniqueProcessId; // receives parent process identifier } pbi; memset( &pbi, 0, sizeof(pbi)); DWORD retLen; __int64 ftCreation,ftExit,ftKernel,ftUser; if(lpfNtQueryInformationProcess(hProcess, 0 /*ProcessBasicInformation*/, &pbi, sizeof(pbi), &retLen)>=0 && TRUE==::GetProcessTimes (hProcess,(FILETIME *)&ftCreation,(FILETIME *)&ftExit,(FILETIME *)&ftKernel,(FILETIME *)&ftUser)){ // The second test is important. It excludes orphaned processes who appear to have been adopted by virtue of a new // process having been created with the same ID as their original parent. PInfo p; p.PID=pid; p.PPID=pbi.InheritedFromUniqueProcessId; p.tCreation=ftCreation; p.tCpu=Time((ftKernel+ftUser)/10000); arPinfo.push_back(p); } CloseHandle(hProcess); } } } delete [] arPids; } } } } break; case VER_PLATFORM_WIN32_WINDOWS: if( hInstLib1) { static HANDLE (WINAPI *lpfCreateToolhelp32Snapshot)(DWORD,DWORD)= (HANDLE(WINAPI *)(DWORD,DWORD))GetProcAddress( hInstLib1,"CreateToolhelp32Snapshot" ) ; static BOOL (WINAPI *lpfProcess32First)(HANDLE,LPPROCESSENTRY32)= (BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))GetProcAddress( hInstLib1, "Process32First" ) ; static BOOL (WINAPI *lpfProcess32Next)(HANDLE,LPPROCESSENTRY32)= (BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))GetProcAddress( hInstLib1, "Process32Next" ) ; if( lpfProcess32Next && lpfProcess32First && lpfCreateToolhelp32Snapshot) { // Get a handle to a Toolhelp snapshot of the systems // processes. HANDLE hSnapShot = lpfCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0) ; if(INVALID_HANDLE_VALUE != hSnapShot) { // Get the first process' information. PROCESSENTRY32 procentry; procentry.dwSize = sizeof(PROCESSENTRY32) ; if(lpfProcess32First( hSnapShot, &procentry )){ rc=true; do { PInfo p; p.PID=procentry.th32ProcessID; p.PPID=procentry.th32ParentProcessID; arPinfo.push_back(p); } while(lpfProcess32Next( hSnapShot, &procentry )); } CloseHandle(hSnapShot); } } } break; default: break; } SetParents(arPinfo); if(!rc){ ERROR(_T("Couldn't get process information!\n")); } return rc; }
void MouseInputSource::handleWheel (ComponentPeer* const peer, const Point<int>& positionWithinPeer, const int64 time, const float x, const float y) { pimpl->handleWheel (peer, positionWithinPeer, Time (time), x, y); }
void MouseInputSource::handleEvent (ComponentPeer* peer, const Point<int>& positionWithinPeer, const int64 time, const ModifierKeys& mods) { pimpl->handleEvent (peer, positionWithinPeer, Time (time), mods.withOnlyMouseButtons()); }
// Static Time Time::fromMicroseconds(Int64 microSeconds){ return Time(microSeconds); };
Time GetSysTime() { return Time(time(NULL)); }
Time BgfxClock::GetElapsedTime() { const double Freq = double( bx::getHPFrequency() ); const double ToMs = 1000.0 / Freq; return Time( bx::getHPCounter() * ToMs * 0.001f ); }
int64 GetUTCSeconds(Time tm) { return tm - Time(1970, 1, 1) + GetLeapSeconds(tm); }
void CTimer::Start(void) { m_TimerLock.Lock(); m_StartTime = Time(); }
Time TimeFromUTC(int64 seconds) { Time tm = Time(1970, 1, 1) + seconds; return tm - GetLeapSeconds(tm); }
void SchedulesTabController::addRule(model::ScheduleRuleset & scheduleRuleset) { model::ScheduleRule rule(scheduleRuleset); rule.daySchedule().addValue(Time(1,0),defaultStartingValue(rule.daySchedule())); }
Time EXP_FUNC systemTime() { return Time(time(NULL)); }
static void trainSetSpeed(const int speed, const int stopTime, const int delayer, Driver* me) { char msg[4]; msg[1] = (char)me->trainNum; if (me->lastSensorActualTime > 0) { // a/d related stuff int newSpeed = speed >=0 ? speed : 0; int now = Time(me->timeserver) * 10; if (me->speed == newSpeed) { // do nothing } else if (me->speed == 0) { // accelerating from 0 int v0 = getVelocity(me); int v1 = me->v[newSpeed][ACCELERATE]; int t0 = now + 8; // compensate for time it takes to send to train int t1 = now + 8 + me->a[newSpeed]; poly_init(&me->adPoly, t0, t1, v0, v1); me->isAding = 1; me->lastReportDist = 0; me->adEndTime = t1; } else if (newSpeed == 0) { // decelerating to 0 int v0 = getVelocity(me); int v1 = me->v[newSpeed][DECELERATE]; int t0 = now + 8; // compensate for time it takes to send to train int t1 = now + 8 + getStoppingTime(me); poly_init(&me->adPoly, t0, t1, v0, v1); me->isAding = 1; me->lastReportDist = 0; me->adEndTime = t1; } } TrainDebug(me, "Train Setting Speed %d", speed); if (speed >= 0) { if (delayer) { TrainDebug(me, "Reversing speed.------- %d", speed); msg[0] = 0xf; msg[1] = (char)me->trainNum; msg[2] = (char)speed; msg[3] = (char)me->trainNum; Putstr(me->com1, msg, 4); //TrainDebug(me, "Next Sensor: %d %d", me->nextSensorIsTerminal, me->lastSensorIsTerminal); // Update prediction if (me->nextSensorIsTerminal) { me->nextSensorBox = me->nextSensorBox == EX ? EN : EX; //TrainDebug(me, "LAst Sensor: %d ", me->lastSensorVal); } else { int action = me->nextSensorVal%2 == 1 ? 1 : -1; me->nextSensorVal = me->nextSensorVal + action; } if (me->lastSensorIsTerminal) { me->lastSensorBox = me->lastSensorBox == EX ? EN : EX; } else { int action = me->lastSensorVal%2 == 1 ? 1 : -1; me->lastSensorVal = me->lastSensorVal + action; } float distTemp = me->distanceFromLastSensor; me->distanceFromLastSensor = me->distanceToNextSensor; me->distanceToNextSensor = distTemp; char valTemp = me->nextSensorVal; me->nextSensorVal = me->lastSensorVal; me->lastSensorVal = valTemp; char boxTemp = me->nextSensorBox; me->nextSensorBox = me->lastSensorBox; me->lastSensorBox = boxTemp; if (me->nextSensorIsTerminal || me->lastSensorIsTerminal){ char isTemp = me->nextSensorIsTerminal; me->nextSensorIsTerminal = me->lastSensorIsTerminal; me->lastSensorIsTerminal = isTemp; } // Reserve the track above train and future (covers case of init) // Update prediction updatePrediction(me); int reserveStatus = reserveMoreTrack(me, 0, me->d[speed][ACCELERATE][MAX_VAL]); // moving if (reserveStatus == RESERVE_FAIL) { reroute(me); } } else { //TrainDebug(me, "Set speed. %d %d", speed, me->trainNum); msg[0] = (char)speed; Putstr(me->com1, msg, 2); if (speed == 0) { int delayTime = stopTime + 500; Reply(me->stopDelayer, (char*)&delayTime, 4); } } if (speed > me->speed) { me->speedDir = ACCELERATE; } else if (speed < me->speed) { me->speedDir = DECELERATE; } me->speed = speed; } else { //TrainDebug(me, "Reverse... %d ", me->speed); DriverMsg delayMsg; delayMsg.type = SET_SPEED; delayMsg.timestamp = stopTime + 500; if (me->speedAfterReverse == -1) { delayMsg.data2 = (signed char)me->speed; } else { delayMsg.data2 = (signed char)me->speedAfterReverse; } //TrainDebug(me, "Using delayer: %d for %d", me->delayer, stopTime); Reply(me->delayer, (char*)&delayMsg, sizeof(DriverMsg)); msg[0] = 0; msg[1] = (char)me->trainNum; Putstr(me->com1, msg, 2); me->speed = 0; me->speedDir = DECELERATE; } }
/** \fn content(po::variables_map const& vm) \brief Execute the NEST synapse Miniapp. \param vm encapsulate the command line and all needed informations */ void model_content(po::variables_map const& vm) { PoorMansAllocator poormansallocpool; double dt = vm["dt"].as<double>(); int iterations = vm["iterations"].as<int>(); const int num_connections = vm["nConnections"].as<int>(); const int num_detectors = vm["nDetectors"].as<int>(); bool with_connector = vm.count("connector") > 0; bool with_manager = vm.count("manager") > 0; //will turn into ptr to base class if more synapse are implemented tsodyks2* syn; ConnectorBase* conn = NULL; //preallocate vector for results std::vector<spikedetector> detectors(num_detectors); std::vector<targetindex> detectors_targetindex(num_detectors); // register spike detectors connectionmanager* cn = NULL; for(unsigned int i=0; i < num_detectors; ++i) { detectors[i].set_lid(i); //give nodes a local id //scheduler stores pointers to the spike detectors detectors_targetindex[i] = scheduler::add_node(&detectors[i]); //add them to the scheduler } if (vm["model"].as<std::string>() == "tsodyks2") { const double delay = vm["delay"].as<double>(); const double weight = vm["weight"].as<double>(); const double U = vm["U"].as<double>(); const double u = vm["u"].as<double>(); const double x = vm["x"].as<double>(); const double tau_rec = vm["tau_rec"].as<double>(); const double tau_fac = vm["tau_fac"].as<double>(); const bool pool = vm["pool"].as<bool>(); if(pool){ poormansallocpool.states = pool; } if ( with_manager ) { //build connection manager cn = new connectionmanager(vm); build_connections_from_neuron(detectors_targetindex, *cn, vm); } else if ( with_connector ) { //build connector for(unsigned int i=0; i < num_connections; ++i) { //TODO permute parameters tsodyks2 synapse(delay, weight, U, u, x, tau_rec, tau_fac, detectors_targetindex[i%num_detectors]); conn = add_connection(conn, synapse); //use static function from connectionmanager } } else { syn = new tsodyks2(delay, weight, U, u, x, tau_rec, tau_fac, detectors_targetindex[0]); } } /* else if () .. further synapse models*/ else { throw std::invalid_argument("connection model implementation missing"); } //create a few events std::vector< spikeevent > events(iterations); for (unsigned int i=0; i<iterations; i++) { Time t(i*10.0); events[i].set_stamp( t ); // in Network::send< SpikeEvent > events[i].set_sender( NULL ); // in Network::send< SpikeEvent > //events[i]->set_sender_gid( sgid ); // Network::send_local } boost::chrono::system_clock::duration delay; if ( with_manager ) { if (cn==NULL) { throw std::runtime_error("connectionmanager pointer is not valid"); } const int t = vm["thread"].as<int>(); // thead_num const int min_delay=vm["min_delay"].as<int>(); const int nSpikes = vm["nSpikes"].as<int>(); const int simtime = iterations * min_delay; const int ngroups = vm["nGroups"].as<int>(); const int rank = vm["rank"].as<int>(); const int size = vm["size"].as<int>(); const int ncells = vm["nNeurons"].as<int>(); //environment::event_generator generator(nSpikes, simtime, ngroups, rank, size, ncells); environment::event_generator generator(ngroups); double mean = static_cast<double>(simtime) / static_cast<double>(nSpikes); double lambda = 1.0 / static_cast<double>(mean * size); environment::generate_poisson_events(generator.begin(), simtime, ngroups, rank, size, ncells, lambda); const unsigned int stats_generated_spikes = generator.get_size(t); int sim_time = 0; spikeevent se; boost::chrono::system_clock::time_point start = boost::chrono::system_clock::now(); for (unsigned int i=0; i<iterations; i++) { sim_time+=min_delay; while(generator.compare_top_lte(t, sim_time)) { environment::gen_event g = generator.pop(t); index nid = g.first; se.set_stamp( Time(g.second) ); // in Network::send< SpikeEvent > se.set_sender_gid( nid ); // in Network::send< SpikeEvent > cn->send(t, nid, se); //send spike } } delay = boost::chrono::system_clock::now() - start; std::cout << "Connection manager simulated" << std::endl; std::cout << "Statistics:" << std::endl; std::cout << "\tgenerated spikes: " << stats_generated_spikes << std::endl; int recvSpikes=0; for (unsigned int i=0; i<detectors.size(); i++) recvSpikes+=detectors[i].spikes.size(); std::cout << "\trecv spikes: " << recvSpikes << std::endl; std::cout << "\tEvents left:" << std::endl; while (!generator.empty(t)) { environment::gen_event g = generator.pop(t); std::cout << "Event " << g.first << " " << g.second << std::endl; } delete cn; } else if ( with_connector ) { if (conn==NULL) { throw std::runtime_error("connector pointer is not valid"); } boost::chrono::system_clock::time_point start = boost::chrono::system_clock::now(); for (unsigned int i=0; i<iterations; i++) { conn->send(events[i]); //send spike } delay = boost::chrono::system_clock::now() - start; std::cout << "Connector simulated with " << num_connections << " connections" << std::endl; } else { if (!syn) { throw std::runtime_error("connection pointer is not valid"); } double t_lastspike = 0.0; boost::chrono::system_clock::time_point start = boost::chrono::system_clock::now(); for (unsigned int i=0; i<iterations; i++) { syn->send(events[i], t_lastspike); //send spike t_lastspike += dt; } delay = boost::chrono::system_clock::now() - start; std::cout << "Single connection simulated" << std::endl; delete syn; } std::cout << "Duration: " << delay << std::endl; std::cout << "Last weight " << detectors[0].spikes.back().get_weight() << std::endl; }
/// multiplication operator Time Time::operator* (double mult) const { return Time(this->totalDays()*mult); }
// Static Time Time::fromSeconds(float seconds){ return Time((Int64)(seconds * 1000000.f)); };
/// get current time of day Time Time::currentTime() { posix_time::ptime now = posix_time::second_clock::local_time(); return Time(now.time_of_day()); }
// Build a Time object from an amount of miliseconds Time Time::fromMiliSeconds(Int64 miliSeconds){ return Time((Int64)(miliSeconds * 10000.f)); };
BOOL MFCArrangeView::OnDrop( COleDataObject* object, DROPEFFECT dropEffect, CPoint point ) { cerr << "MFCArrangeView::on drop"<<endl; point += GetScrollPosition(); switch (dragon.type) { case QuaDrop::FILES: case QuaDrop::AUDIOFILES: case QuaDrop::MIDIFILES: { Time at_time; short at_channel; Pix2Time(point.x, at_time); at_channel = Pix2Channel(point.y); std::cerr << "file drop " << at_channel << " chan " << at_time.StringValue() << endl; // int bar, barbeat, beattick; // at_time.GetBBQValue(bar, barbeat, beattick); // fprintf(stderr, "drag files is dropped: on point %d %d, channel %d, ticks %d t %d:%d.%d\n", point.x, point.y, at_channel, at_time.ticks, bar, barbeat, beattick); short i; bool drop_sample_file=false; bool drop_midi_file=false; bool drop_qua_file=false; for (i=0; ((unsigned)i)<dragon.data.filePathList->size(); i++) { string mime_t = Qua::identifyFile(dragon.data.filePathList->at(i)); if (mime_t.size() > 0) { std::cout << "drop " << dragon.data.filePathList->at(i) << ", " << mime_t << endl; if (mime_t == "audio/x-midi") { drop_midi_file = true; break; } else if (mime_t == "audio/x-wav" || mime_t == "audio/x-raw" || mime_t == "audio/x-aiff") { drop_sample_file = true; break; } else if (mime_t == "audio/x-quascript") { drop_qua_file = true; break; } } else { // fprintf(stderr, "dragged file %d unidentifiable\n", i); } } if (i == dragon.count) { // didn't find something useable in the drop return FALSE; } if (drop_sample_file) { StabEnt *s = quaLink->CreateSample("", *dragon.data.filePathList); quaLink->CreateInstance(s, at_channel, at_time, Time()); } else if (drop_midi_file) { ; } else if (drop_qua_file) { ; } else { return FALSE; } return TRUE; } case QuaDrop::VSTPLUGIN: case QuaDrop::VOICE: case QuaDrop::SAMPLE: case QuaDrop::SCHEDULABLE: { Time at_time; short at_channel; Pix2Time(point.x, at_time); at_channel = Pix2Channel(point.y); cerr << "schedulable drop " << at_channel << " chan " << at_time.StringValue() << endl; // int bar, barbeat, beattick; // at_time.GetBBQValue(bar, barbeat, beattick); // fprintf(stderr, "drop schedulable %s: on point %d %d, channel %d, ticks %d t %d:%d.%d\n", dragon.data.symbol->name, point.x, point.y, at_channel, at_time.ticks, bar, barbeat, beattick); quaLink->CreateInstance(dragon.data.symbol, at_channel, at_time, Time::zero); return TRUE; } case QuaDrop::INSTANCE: { Time at_time; short at_channel; Pix2Time(point.x, at_time); at_channel = Pix2Channel(point.y); std::cerr << "instance drop " << at_channel << " chan " << at_time.StringValue() << endl; // int bar, barbeat, beattick; // at_time.GetBBQValue(bar, barbeat, beattick); // fprintf(stderr, "drop instance %s: on point %d %d, channel %d, ticks %d t %d:%d.%d\n", dragon.data.symbol->name, point.x, point.y, at_channel, at_time.ticks, bar, barbeat, beattick); Instance *i = dragon.data.symbol->InstanceValue(); if (i != nullptr) { quaLink->MoveInstance(dragon.data.symbol, at_channel, at_time, i->duration); } else { std::cout << "oops bad drop ... expected an instance" << endl; } return TRUE; } case QuaDrop::APPLICATION: case QuaDrop::PORT: case QuaDrop::BUILTIN: case QuaDrop::TEMPLATE: switch (dropEffect) { case DROPEFFECT_COPY: fprintf(stderr, "left click drag: on drop copy %d %d\n", point.x, point.y); break; case DROPEFFECT_MOVE: fprintf(stderr, "left click drag: on drop move %d %d\n", point.x, point.y); break; case DROPEFFECT_LINK: fprintf(stderr, "left click drag: on drop link %d %d\n", point.x, point.y); break; } break; } return FALSE; }
void notify_ADMINX(Connection *xConn,PCStr(admin),PCStr(what),PCStr(body)) { FILE *tmp; FILE *bt; Connection ConnBuff,*Conn = &ConnBuff; CStr(head,1024); CStr(me,128); CStr(date,128); CStr(load,128); CStr(cwd,1024); CStr(uname,128); int now; const char *bugbox = "*****@*****.**"; CStr(msgid,1024); CStr(buf,1024); if( strncasecmp(what,"sig",3) != 0 ) if( strncasecmp(what,"failed",6) != 0 ) if( strncasecmp(what,"modified",8) != 0 ) if( strncasecmp(what,"approved",8) != 0 ) if( strncasecmp(what,"detected",8) != 0 ) if( strncasecmp(what,"[",1) != 0 ) /* abort in child process */ return; if( admin == NULL || *admin == 0 ) admin = getADMIN1(); now = time(NULL); if( xConn ) *Conn = *xConn; else bzero(Conn,sizeof(Connection)); tmp = TMPFILE("NOTIFY"); head[0] = 0; if( gethostname(me,sizeof(me)) != 0 ) strcpy(me,"?"); sprintf(msgid,"%d.%d.%d@%s",getpid(),itime(0),getuid(),me); StrftimeLocal(AVStr(date),sizeof(date),TIMEFORM_RFC822,now,0); Xsprintf(TVStr(head),"Subject: DeleGate-Report: %s\r\n",what); Xsprintf(TVStr(head),"From: [%d]@%s\r\n",getuid(),me); Xsprintf(TVStr(head),"To: %s (DeleGate ADMIN)\r\n",admin); Xsprintf(TVStr(head),"Reply-To: %s\r\n",bugbox); Xsprintf(TVStr(head),"Date: %s\r\n",date); Xsprintf(TVStr(head),"Message-Id: <%s>\r\n",msgid); Xsprintf(TVStr(head),"Content-Type: text/plain\r\n"); fprintf(tmp,"%s\r\n",head); fprintf(tmp,"PLEASE FORWARD THIS MESSAGE TO <%s>.\r\n",bugbox); fprintf(tmp,"IT WILL BE HELPFUL FOR DEBUGGING.\r\n"); fprintf(tmp,"\r\n"); fprintf(tmp,"%s",head); fprintf(tmp,"Event: %s\r\n",what); Uname(AVStr(uname)); fprintf(tmp,"Version: %s (%s)\r\n",DELEGATE_verdate(),uname); fprintf(tmp,"Host: %s\r\n",me); fprintf(tmp,"Owner: uid=%d/%d, gid=%d/%d\r\n", geteuid(),getuid(),getegid(),getgid()); StrftimeLocal(AVStr(date),sizeof(date),TIMEFORM_RFC822,START_TIME,0); fprintf(tmp,"Started: %s\r\n",date); fprintf(tmp,"Pid: %d\r\n",getpid()); cwd[0] = 0; IGNRETS getcwd(cwd,sizeof(cwd)); fprintf(tmp,"Cwd: %s\r\n",cwd); strfLoadStat(AVStr(load),sizeof(load),"%L (%l)",now); fprintf(tmp,"Load: %s\r\n",load); fprintf(tmp,"Stack: %X %d/%d\r\n",p2i(STACK_PEAK),ll2i(STACK_BASE-STACK_PEAK), STACK_SIZE); fprintf(tmp,"\r\n"); if( iamServer() ) { } else { fprintf(tmp,"Client-Proto: %s\r\n",CLNT_PROTO); fprintf(tmp,"Client-Host: %s:%d\r\n",Client_Addr(buf),Client_Port); if( TeleportHost[0] ) fprintf(tmp,"Rident-Host: %s:%d..%s:%d\r\n",TelesockHost,TelesockPort, TeleportAddr,TeleportPort); fprintf(tmp,"\r\n"); } fprintf(tmp,"%s\r\n",body); /* if( strncasecmp(what,"sig",3) == 0 || *what == '[' ){ */ if( strncasecmp(what,"sig",3) == 0 || strncasecmp(what,"failed",6) == 0 || *what == '[' ) { fprintf(tmp,"--iLog--begin\r\n"); iLOGdump1(tmp,0); fprintf(tmp,"--iLog--end\r\n"); fprintf(tmp,"\r\n"); fprintf(tmp,"--AbortLog--begin\r\n"); putAbortLog(tmp); fprintf(tmp,"--AbortLog--end\r\n"); } if( strncasecmp(what,"sig",3) == 0 ) { int btout[2]; double Start = Time(); int rcc; fprintf(tmp,"\r\n"); fprintf(tmp,"--BackTrace--begin\r\n"); fflush(tmp); if( pipe(btout) == 0 ) { setNonblockingIO(btout[1],1); bt = fdopen(btout[1],"w"); putBackTrace(bt); fclose(bt); bt = fdopen(btout[0],"r"); rcc = file_copyTimeout(bt,tmp,NULL,128*1024,NULL,15); fclose(bt); sv1log("BatckTrace: %dB / %.1fs\n",rcc,Time()-Start); } else { bt = TMPFILE("BackTrace"); putBackTrace(bt); fseek(bt,0,0); copyfile1(bt,tmp); fclose(bt); } fprintf(tmp,"\r\n"); fprintf(tmp,"--BackTrace--end\r\n"); } fflush(tmp); fseek(tmp,0,0); if( curLogFp() ) { CStr(line,1024); while( fgets(line,sizeof(line),tmp) != NULL ) fprintf(curLogFp(),"--ABORT-- %s",line); fseek(tmp,0,0); } Conn->co_mask = (CONN_NOPROXY | CONN_NOMASTER); sendmail1(Conn,admin,admin,tmp,NULL); fclose(tmp); }