void draw(SkCanvas* canvas) { SkRegion* region = new SkRegion({1, 2, 3, 4}); SkRegion region2(*region); delete region; auto r = region2.getBounds(); SkDebugf("region2 bounds: {%d,%d,%d,%d}\n", r.fLeft, r.fTop, r.fRight, r.fBottom); }
/** * @brief Draws a subrectangle of this surface on another surface. * @param region The subrectangle to draw in this object. * @param dst_surface The destination surface. * @param dst_position Coordinates on the destination surface. */ void Surface::raw_draw_region(const Rectangle& region, Surface& dst_surface, const Rectangle& dst_position) { // Make a copy of the rectangle because SDL_BlitSurface modifies it. Rectangle region2(region); Rectangle dst_position2(dst_position); SDL_BlitSurface(internal_surface, region2.get_internal_rect(), dst_surface.internal_surface, dst_position2.get_internal_rect()); }
void VendorHandler::pass2to1() { setValid1(true); setName1(name2()); setStreet1(street2()); setCity1(city2()); setState1(state2()); setRegion1(region2()); setTime1(time2()); setZip1(zip2()); setPrice1(price2()); }
void SharedMemoryUtils::refreshMsm_Edit(char type, uint64_t mirandaId, std::wstring& displayName) { logger->log_p(L"SharedMemoryUtils.refreshMsm_Edit type=[%c], mirandaId=[%I64u]", type, mirandaId); boost::ptr_list<boost::interprocess::windows_shared_memory>::iterator msmListIter; for (msmListIter = msmList.begin(); msmListIter != msmList.end(); msmListIter++){ for (int recordNo = 0; recordNo < SMUCONST_MSM_RECORDS_COUNT; recordNo++ ){ boost::interprocess::mapped_region region1( *msmListIter, boost::interprocess::read_only, SMUCONST_MSM_HEADER_SIZE + (recordNo * SMUCONST_MSM_RECORD_SIZE) + SMUCONST_MSM_RECORD_TYPE_RECOFFSET, SMUCONST_MSM_RECORD_TYPE_SIZE ); char* recordTypePtr = static_cast<char*>(region1.get_address()); if (*recordTypePtr == type){ boost::interprocess::mapped_region region2( *msmListIter, boost::interprocess::read_only, SMUCONST_MSM_HEADER_SIZE + (recordNo * SMUCONST_MSM_RECORD_SIZE) + SMUCONST_MSM_RECORD_HANDLE_RECOFFSET, SMUCONST_MSM_RECORD_HANDLE_SIZE ); uint64_t* agcHandlePtr = static_cast<uint64_t*>(region2.get_address()); if (*agcHandlePtr == mirandaId){ boost::interprocess::mapped_region region3( *msmListIter, boost::interprocess::read_write, SMUCONST_MSM_HEADER_SIZE + (recordNo * SMUCONST_MSM_RECORD_SIZE) + SMUCONST_MSM_RECORD_DNAME_RECOFFSET, SMUCONST_MSM_RECORD_DNAME_SIZE ); wchar_t* recordValuePtr = static_cast<wchar_t*>(region3.get_address()); wcsncpy_s(recordValuePtr, SMUCONST_MSM_RECORD_DNAME_SIZEC, displayName.c_str(), _TRUNCATE); logger->log(L"SharedMemoryUtils::refreshMsm_Edit record found and edited"); // unique record found and edited return; } } } } return; }
bool SharedMemoryUtils::isAnyMirandaCsmRecordAvailable(std::wstring& forThisProfileName) { for (int recordNo = 0; recordNo < SMUCONST_CSM_RECORDS_COUNT; recordNo++ ){ boost::interprocess::mapped_region region1( *csm, boost::interprocess::read_only, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_STATUS_RECOFFSET, SMUCONST_CSM_RECORD_STATUS_SIZE ); char* recordStatusPtr = static_cast<char*>(region1.get_address()); if (*recordStatusPtr == 'W'){ boost::interprocess::mapped_region region2( *csm, boost::interprocess::read_only, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_TYPE_RECOFFSET, SMUCONST_CSM_RECORD_TYPE_SIZE ); char* recordTypePtr = static_cast<char*>(region2.get_address()); if (*recordTypePtr == 'M'){ boost::interprocess::mapped_region region3( *csm, boost::interprocess::read_only, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_VISABLETO_RECOFFSET, SMUCONST_CSM_RECORD_VISABLETO_SIZE ); wchar_t* recordVisabletoPtr = static_cast<wchar_t*>(region3.get_address()); std::wstring visableTo = recordVisabletoPtr; if (isTokenOnList(forThisProfileName, visableTo)){ return true; } }//end if M }//end if W }//end for return false; }
QList<Task*> CustomPatternAnnotationTask::onSubTaskFinished(Task* subTask) { QList<Task*> subTasks; if (!taskFeatureNames.contains(subTask)) { return subTasks; } SArrayBasedFindTask* task = static_cast<SArrayBasedFindTask*> (subTask); const QList<int>& results = task->getResults(); PatternInfo info = taskFeatureNames.take(task); qint64 seqLen = dnaObj.getSequenceLength(); foreach (int pos, results) { if (pos > dnaObj.getSequenceLength()) { continue; } int endPos = pos + task->getQuery().length() - 1; SharedAnnotationData data(new AnnotationData); data->name = info.name; U2Strand strand = info.forwardStrand ? U2Strand::Direct : U2Strand::Complementary; data->setStrand(strand); if (dnaObj.isCircular() && endPos > seqLen) { int outerLen = endPos - seqLen; int innerLen = task->getQuery().length() - outerLen; U2Region region1(pos - 1, innerLen); U2Region region2(0, outerLen); data->location->regions << region1 << region2; data->setLocationOperator(U2LocationOperator_Join); } else { U2Region region(pos - 1, task->getQuery().length()); data->location->regions << region; } annotations.append(data); } if (taskFeatureNames.isEmpty() && annotations.size() > 0) { subTasks.append(new CreateAnnotationsTask(aTableObj, annotations, featureStore->getName())); } return subTasks; }
void SharedMemoryUtils::refreshMsm_Delete(char type, uint64_t mirandaId) { logger->log_p(L"SharedMemoryUtils.refreshMsm_Delete type=[%c], mirandaId=[%I64u]", type, mirandaId); boost::ptr_list<boost::interprocess::windows_shared_memory>::iterator msmListIter; for (msmListIter = msmList.begin(); msmListIter != msmList.end(); msmListIter++){ for (int recordNo = 0; recordNo < SMUCONST_MSM_RECORDS_COUNT; recordNo++ ){ boost::interprocess::mapped_region region1( *msmListIter, boost::interprocess::read_write, SMUCONST_MSM_HEADER_SIZE + (recordNo * SMUCONST_MSM_RECORD_SIZE) + SMUCONST_MSM_RECORD_TYPE_RECOFFSET, SMUCONST_MSM_RECORD_TYPE_SIZE ); char* recordTypePtr = static_cast<char*>(region1.get_address()); if (*recordTypePtr == type){ boost::interprocess::mapped_region region2( *msmListIter, boost::interprocess::read_only, SMUCONST_MSM_HEADER_SIZE + (recordNo * SMUCONST_MSM_RECORD_SIZE) + SMUCONST_MSM_RECORD_HANDLE_RECOFFSET, SMUCONST_MSM_RECORD_HANDLE_SIZE ); uint64_t* agcHandlePtr = static_cast<uint64_t*>(region2.get_address()); if (*agcHandlePtr == mirandaId){ *recordTypePtr = 'D'; //[D] deleted - will not be read by other sm clients (even older) logger->log(L"SharedMemoryUtils::refreshMsm_Delete record found and deleted"); // unique record found and edited return; } } } } return; }
void SharedMemoryUtils::checkAnotherCsm(boost::interprocess::windows_shared_memory& checkedCsm, uint16_t processCsmId){ time_t currentTimestamp = mfGetCurrentTimestamp(); for (uint16_t recordNo = 0; recordNo < SMUCONST_CSM_RECORDS_COUNT; recordNo++ ){ if (recordNo == processCsmId - 1){ //do not check own record continue; } boost::interprocess::mapped_region region1( checkedCsm, boost::interprocess::read_write, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_STATUS_RECOFFSET, SMUCONST_CSM_RECORD_STATUS_SIZE ); char* recordStatusPtr = static_cast<char*>(region1.get_address()); if (*recordStatusPtr == 'W'){ //for every record in status (W) Working boost::interprocess::mapped_region region2( checkedCsm, boost::interprocess::read_write, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_KAT_RECOFFSET, SMUCONST_CSM_RECORD_KAT_SIZE ); time_t* recordKatPtr = static_cast<time_t*>(region2.get_address()); double timeDiff = /*std::*/difftime(currentTimestamp, *recordKatPtr); logger->log_p(L"checkAnotherCsm: recordNo=%u (processCsmId=%u) status==W timeDiff=%f", recordNo, recordNo+1, timeDiff); if (timeDiff > CSMTHREAD_RECORD_MAXAGE){ logger->log(L"checkAnotherCsm: free record in CSM"); freeCsmRecord(checkedCsm, recordNo); } }//end if }//end for }
Blob MomentCalculation2::getMomentsInaBlob(Mat boxImage, Mat cmaskImage, string blobId,string profileId){ cvtColor(boxImage, boxImage, CV_BGR2HSV); //Average HumanProportions prop; int boxHeight = boxImage.rows; double ratio = (double)boxHeight / (double)prop.height; int region1Height = (int)(((double)prop.head) * ratio); int region2Height = (int)(((double)prop.gait) * ratio); int region3Height = (int)(((double)prop.leg) * ratio); string placement = "Top"; Region region1(placement, 0, 0, region1Height, boxImage.cols); MomentCalculation2 mcalc; MomentAverage momentAverage1 = mcalc.getAverageColourInConvexRegion(boxImage, cmaskImage, ®ion1); MomentStandardDeviation momentStandardDeviation1 = mcalc.getStandardDeviationInConvexRegion(boxImage, cmaskImage, ®ion1, &momentAverage1); MomentSkewness momentSkewness1 = mcalc.getSkewnessnInConvexRegion(boxImage, cmaskImage, ®ion1, &momentAverage1); region1.setMoments(&momentAverage1, &momentStandardDeviation1, &momentSkewness1); placement = "Middle"; Region region2(placement, 0, 0, region2Height, boxImage.cols); MomentAverage momentAverage2 = mcalc.getAverageColourInConvexRegion(boxImage, cmaskImage, ®ion2); MomentStandardDeviation momentStandardDeviation2 = mcalc.getStandardDeviationInConvexRegion(boxImage, cmaskImage, ®ion2, &momentAverage2); MomentSkewness momentSkewness2 = mcalc.getSkewnessnInConvexRegion(boxImage, cmaskImage, ®ion2, &momentAverage2); region2.setMoments(&momentAverage2, &momentStandardDeviation2, &momentSkewness2); placement = "Bottum"; Region region3(placement, 0, 0, region3Height, boxImage.cols); MomentAverage momentAverage3 = mcalc.getAverageColourInConvexRegion(boxImage, cmaskImage, ®ion3); MomentStandardDeviation momentStandardDeviation3 = mcalc.getStandardDeviationInConvexRegion(boxImage, cmaskImage, ®ion3, &momentAverage3); MomentSkewness momentSkewness3 = mcalc.getSkewnessnInConvexRegion(boxImage, cmaskImage, ®ion3, &momentAverage3); region3.setMoments(&momentAverage3, &momentStandardDeviation3, &momentSkewness3); Blob blob(blobId, boxImage.rows, boxImage.cols); blob.human_id_actual = profileId; blob.addRegion(®ion1); blob.addRegion(®ion2); blob.addRegion(®ion3); return blob; }
double Evaluate(double *x) { if (x[0] <= p[16]){ return region1(x[0],p); } else if (x[0] <= p[17]){ return region2(x[0]-p[16],p); } else if (x[0] <= p[18]){ return region3(x[0]-p[17],p); } else if (x[0] <= p[19]){ return region4(x[0]-p[18],p); } else { return region5(x[0]-p[19],p); } }
void SharedMemoryUtils::initCsm(boost::interprocess::windows_shared_memory& csm) { //save csm header version boost::interprocess::mapped_region region1( csm, boost::interprocess::read_write, SMUCONST_CSM_HEADER_VERSION_OFFSET, SMUCONST_CSM_HEADER_VERSION_SIZE ); uint32_t* versionPtr = static_cast<uint32_t*>(region1.get_address()); *versionPtr = SMUCONST_CSM_CURRENT_VERSION; //prepare records for (uint16_t recordNo = 0; recordNo < SMUCONST_CSM_RECORDS_COUNT; recordNo++ ){ //save scm record id (=recordNo) boost::interprocess::mapped_region region2( csm, boost::interprocess::read_write, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_RECID_RECOFFSET, SMUCONST_CSM_RECORD_RECID_SIZE ); uint16_t* recordIdPtr = static_cast<uint16_t*>(region2.get_address()); *recordIdPtr = recordNo + 1; //save scm record status (=E (Empty)) boost::interprocess::mapped_region region3( csm, boost::interprocess::read_write, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_STATUS_RECOFFSET, SMUCONST_CSM_RECORD_STATUS_SIZE ); char* recordStatusPtr = static_cast<char*>(region3.get_address()); *recordStatusPtr = 'E'; } }
int SharedMemoryUtils::checkCsmRecord(boost::interprocess::windows_shared_memory& checkedCsm, uint16_t processCsmId, std::wstring& displayNameProfile) { uint16_t recordNo = processCsmId - 1; boost::interprocess::mapped_region region1( checkedCsm, boost::interprocess::read_write, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_STATUS_RECOFFSET, SMUCONST_CSM_RECORD_STATUS_SIZE ); char* recordStatusPtr = static_cast<char*>(region1.get_address()); if (*recordStatusPtr == 'W'){ boost::interprocess::mapped_region region2( checkedCsm, boost::interprocess::read_only, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_DNAME_RECOFFSET, SMUCONST_CSM_RECORD_DNAME_SIZE ); wchar_t* displayNamePtr = static_cast<wchar_t*>(region2.get_address()); std::wstring displayNameSM = displayNamePtr; if (displayNameSM.compare(displayNameProfile) == 0){ return 0; //OK } else { logger->log_p(L"checkCsmRecord not ok for processCsmId = %u: displayNameProfile [%s] doesn't match displayNameSM [%s].", processCsmId, displayNameProfile.c_str(), displayNameSM.c_str()); return 1; //csm record data corrupted - displayName not match } } else { logger->log_p(L"checkCsmRecord not ok for processCsmId = %u: recordStatus is [%c] expected [W].", processCsmId, *recordStatusPtr); return 1; //csm record data corrupted - not in state W } }
void MessageQueueUtils::sendMessage(int clientRecordId, char menuItemType, char userActionType, char userButton, uint64_t targetHandle, std::wstring userActionSelection) { logger->log(L"MessageQueueUtils::sendMessage"); //if text to send is too long if (userActionSelection.size() > MQCONST_MQSM_TEXT_SIZEC){ userActionSelection.resize(MQCONST_MQSM_TEXT_SIZEC - 3); userActionSelection.append(TEXT("...")); } try{ boost::interprocess::windows_shared_memory* sm = new boost::interprocess::windows_shared_memory( boost::interprocess::open_only, getMqName(clientRecordId).c_str(), boost::interprocess::read_write); if (sm == NULL){ logger->log(L"MessageQueueUtils::sendMessage (sm mode) sm == NULL"); return; //error } int counter = 0; const int MQ_WAIT_TIME = 200; //[ms] const int MAX_MQ_WAIT_COUNTER = 10; //10 * 200ms = 2s bool sentSuccess = false; do { counter++; WaitForSingleObject(smMutex, INFINITE); boost::interprocess::mapped_region region1( *sm, boost::interprocess::read_write, MQCONST_MQMIRSM_STATUS_OFFSET, MQCONST_MQMIRSM_STATUS_SIZE ); char* mqmirsmStatusPtr = static_cast<char*>(region1.get_address()); if (*mqmirsmStatusPtr == 'E'){ boost::interprocess::mapped_region region2( *sm, boost::interprocess::read_write, MQCONST_MQMIRSM_MENUITEMTYPE_OFFSET, MQCONST_MQMIRSM_MENUITEMTYPE_SIZE ); char* menuItemTypePtr = static_cast<char*>(region2.get_address()); *menuItemTypePtr = menuItemType; boost::interprocess::mapped_region region3( *sm, boost::interprocess::read_write, MQCONST_MQMIRSM_USERACTIONTYPE_OFFSET, MQCONST_MQMIRSM_USERACTIONTYPE_SIZE ); char* userActionTypePtr = static_cast<char*>(region3.get_address()); *userActionTypePtr = userActionType; boost::interprocess::mapped_region region4( *sm, boost::interprocess::read_write, MQCONST_MQMIRSM_USERBUTTON_OFFSET, MQCONST_MQMIRSM_USERBUTTON_SIZE ); char* userButtonPtr = static_cast<char*>(region4.get_address()); *userButtonPtr = userButton; boost::interprocess::mapped_region region5( *sm, boost::interprocess::read_write, MQCONST_MQMIRSM_TARGETHANDLE_OFFSET, MQCONST_MQMIRSM_TARGETHANDLE_SIZE ); uint64_t* targetHandlePtr = static_cast<uint64_t*>(region5.get_address()); *targetHandlePtr = targetHandle; boost::interprocess::mapped_region region6( *sm, boost::interprocess::read_write, MQCONST_MQMIRSM_TEXTARRAY_OFFSET, MQCONST_MQMIRSM_TEXTARRAY_SIZE ); wchar_t* userActionSelectionPtr = static_cast<wchar_t*>(region6.get_address()); memset(userActionSelectionPtr, 0, MQCONST_MQMIRSM_TEXTARRAY_SIZE); memcpy(userActionSelectionPtr, userActionSelection.c_str(), userActionSelection.length() * sizeof(wchar_t)); //update shared memory status to Message *mqmirsmStatusPtr = 'M'; sentSuccess = true; } // else wait and repeat try ReleaseMutex(smMutex); if (!sentSuccess){ SleepEx(MQ_WAIT_TIME, TRUE); } } while (sentSuccess == false && counter <= MAX_MQ_WAIT_COUNTER); if (!sentSuccess){ logger->log(L"MessageQueueUtils::sendMessage (sm mode) - MAX_MQ_WAIT_COUNTER exceeded but still sentSuccess == false"); } delete sm; } catch (const boost::interprocess::interprocess_exception& ex) { logger->log_p(L"MessageQueueUtils::sendMessage (sm mode) interprocess_exception: [%S] native_error=[%d] error_code=[%d]", ex.what(), ex.get_native_error(), ex.get_error_code() ); return; //error } catch (...){ logger->log(L"MessageQueueUtils::sendMessage (sm mode) EXCEPTION: unknown"); return; //error } }
TEST_F(TestConcurrentCompositeStateNoArgs,MultipleRegions) { typedef TestConcurrentCompositeStateNoArgsMock < TestStateMachineNoEventArgsMock > ConcurrentCompositeStateMockType; ::testing::NiceMock<TestStateMachineNoEventArgsMock> stateMachine; ::testing::NiceMock < ConcurrentCompositeStateMockType > compositeState(&stateMachine); ::testing::NiceMock < TestRegionNoArgsMock<ConcurrentCompositeStateMockType> > region1(&compositeState); ::testing::NiceMock < TestRegionNoArgsMock<ConcurrentCompositeStateMockType> > region2(&compositeState); stateMachine.autoFinalize(false); compositeState.setRegion(0,®ion1); compositeState.setRegion(1,®ion2); stateMachine.initialState(&compositeState); // Setup mock call expectations //---------------------------------------------------------------------------- EXPECT_CALL(compositeState,entryImpl(&stateMachine)) .Times(1); EXPECT_CALL(compositeState,startDoImpl(&stateMachine)) .Times(1); EXPECT_CALL(compositeState,endDoImpl(&stateMachine)) .Times(1); EXPECT_CALL(compositeState,exitImpl(&stateMachine)) .Times(1); // Check region calls EXPECT_CALL(region1,enterRegionImpl(&compositeState)) .Times(1); EXPECT_CALL(region1,startingRegionThread()) .Times(1); EXPECT_CALL(region1,initializeImpl(_)) .Times(1); EXPECT_CALL(region1,handleEvent1(&compositeState,®ion1)) .Times(1); EXPECT_CALL(region1,handleEvent2(&compositeState,®ion1)) .Times(1); EXPECT_CALL(region1,handleEvent3(&compositeState,®ion1)) .Times(1); EXPECT_CALL(region1,handleEvent4(&compositeState,®ion1)) .Times(1); EXPECT_CALL(region1,finalizeImpl(_)) .Times(1); EXPECT_CALL(region1,endingRegionThread()) .Times(1); EXPECT_CALL(region1,exitRegionImpl(&compositeState)) .Times(1); EXPECT_CALL(region2,enterRegionImpl(&compositeState)) .Times(1); EXPECT_CALL(region2,startingRegionThread()) .Times(1); EXPECT_CALL(region2,initializeImpl(_)) .Times(1); EXPECT_CALL(region2,handleEvent1(&compositeState,®ion2)) .Times(1); EXPECT_CALL(region2,handleEvent2(&compositeState,®ion2)) .Times(1); EXPECT_CALL(region2,handleEvent3(&compositeState,®ion2)) .Times(1); EXPECT_CALL(region2,handleEvent4(&compositeState,®ion2)) .Times(1); EXPECT_CALL(region2,finalizeImpl(_)) .Times(1); EXPECT_CALL(region2,endingRegionThread()) .Times(1); EXPECT_CALL(region2,exitRegionImpl(&compositeState)) .Times(1); // Run the state machine //---------------------------------------------------------------------------- // STTCL_TEST_LOG_ALL(); // compositeState.enableLogging(true); // innerState.enableLogging(true); stateMachine.initialize(); // Give the region thread(s) a chance to run sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100)); stateMachine.triggerEvent1(); // Give the region thread(s) a chance to run sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100)); stateMachine.triggerEvent2(); // Give the region thread(s) a chance to run sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100)); stateMachine.triggerEvent3(); // Give the region thread(s) a chance to run sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100)); stateMachine.triggerEvent4(); // Give the region thread(s) a chance to run sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100)); stateMachine.finalize(); // Give the region thread(s) a chance to run sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100)); EXPECT_TRUE(region1.waitForDoActionExited(sttcl::TimeDuration<>(0,0,0,100),10)); // STTCL_TEST_LOG_END(); }
/* GAME(): Constructor */ GAME::GAME() { #ifdef DEBUG printf("Game Created\n"); #endif _ft = 0.0f; _ftTimer = 0.0f; _fps = 0; _fpsCounter = 0; _lighting = true; _displayAxis = true; _displayNormals = false; _displayBiNormals = false; _displayTangents = false; _displayPoints = false; _displayWireframe = false; _displaySlopes = false; _players = NULL; _terrain = NULL; /* Initialise Multiple Players */ bool splitScreen = false; _playerCount = splitScreen ? PLAYERS_2 : PLAYERS_1; _players = new Player[_playerCount]; for (int i=0; i<_playerCount; i++) _players[i] = Player(); if (_playerCount == PLAYERS_1) { _players[0].skier = new SKIER(); _players[0].camera = new CAMERA(); _players[0].emitter = new EMITTER(PARTICLE_COUNT); _players[0].stream = 0; } else { _players[0].skier = new SKIER(vec3(-10, 0, 0) ); _players[0].camera = new CAMERA(region2(0, 0, 0.5f, 1) ); _players[0].emitter = new EMITTER(PARTICLE_COUNT); _players[0].stream = 0; _players[1].skier = new SKIER(vec3(10, 0, 0) ); _players[1].camera = new CAMERA(region2(0.5f, 0, 1, 1) ); _players[1].emitter = new EMITTER(PARTICLE_COUNT); _players[1].stream = 1; } _terrain = new TERRAIN(_playerCount); _trees = new TREES(); _skybox = new SKYBOX(); }
/** * return true if message was received and variables are available */ bool MessageQueueUtils::tryReceiveMessage(char& menuItemType, char& userActionType, char& userButton, uint64_t& targetHandle, wchar_t*& userActionSelection, size_t uasBuffCSize) { try{ WaitForSingleObject(smMutex, 100000); boost::interprocess::mapped_region region1( *mqMirSm, boost::interprocess::read_write, MQCONST_MQMIRSM_STATUS_OFFSET, MQCONST_MQMIRSM_STATUS_SIZE ); char* mqmirsmStatusPtr = static_cast<char*>(region1.get_address()); if (*mqmirsmStatusPtr != 'M'){ ReleaseMutex(smMutex); return false; } //there is a new message in the queue (sm mode) *mqmirsmStatusPtr=='M' //transfer data from shared memory to variables boost::interprocess::mapped_region region2( *mqMirSm, boost::interprocess::read_only, MQCONST_MQMIRSM_MENUITEMTYPE_OFFSET, MQCONST_MQMIRSM_MENUITEMTYPE_SIZE ); menuItemType = *(static_cast<char*>(region2.get_address())); boost::interprocess::mapped_region region3( *mqMirSm, boost::interprocess::read_only, MQCONST_MQMIRSM_USERACTIONTYPE_OFFSET, MQCONST_MQMIRSM_USERACTIONTYPE_SIZE ); userActionType = *(static_cast<char*>(region3.get_address())); boost::interprocess::mapped_region region4( *mqMirSm, boost::interprocess::read_only, MQCONST_MQMIRSM_USERBUTTON_OFFSET, MQCONST_MQMIRSM_USERBUTTON_SIZE ); userButton = *(static_cast<char*>(region4.get_address())); boost::interprocess::mapped_region region5( *mqMirSm, boost::interprocess::read_only, MQCONST_MQMIRSM_TARGETHANDLE_OFFSET, MQCONST_MQMIRSM_TARGETHANDLE_SIZE ); targetHandle = *(static_cast<uint64_t*>(region5.get_address())); boost::interprocess::mapped_region region6( *mqMirSm, boost::interprocess::read_only, MQCONST_MQMIRSM_TEXTARRAY_OFFSET, MQCONST_MQMIRSM_TEXTARRAY_SIZE ); wchar_t* userActionSelectionPtr = static_cast<wchar_t*>(region6.get_address()); wcsncpy_s(userActionSelection, uasBuffCSize, userActionSelectionPtr, MQCONST_MQMIRSM_TEXTARRAY_SIZEC); //update shared memory status to Empty *mqmirsmStatusPtr = 'E'; ReleaseMutex(smMutex); } catch (const boost::interprocess::interprocess_exception& ex) { logger->log_p(L"MessageQueueUtils::tryReceiveMessage interprocess_exception: [%S] native_error=[%d] error_code=[%d]", ex.what(), ex.get_native_error(), ex.get_error_code() ); return false; } catch (...){ logger->log(L"MessageQueueUtils::tryReceiveMessage EXCEPTION: unknown"); return false; } logger->log_p(L"MessageQueueUtils::tryReceiveMessage (mq mode) RECEIVED DATA: menuItemType = [%c] userActionType = [%c] userButton = [%c] targetHandle = [%I64u]", menuItemType, userActionType, userButton, targetHandle); return true; }
int SharedMemoryUtils::getAccounts(boost::ptr_list<AccountClass> * accountsListPtr, unsigned short clientRecordNo) { if (accountsListPtr==NULL){ logger->log(L"SharedMemoryUtils::getAccounts contactsListPtr==NULL"); return -1; } bool isMsmAvailable = true; int msmNumber = 1; std::string msmName; boost::interprocess::windows_shared_memory* msm; int foundAccountsCount = 0; do { //get MSM to seek accounts msmName = getMsmName(clientRecordNo, msmNumber); msmNumber++; try { msm = new boost::interprocess::windows_shared_memory( boost::interprocess::open_only, msmName.c_str(), boost::interprocess::read_only); } catch (const boost::interprocess::interprocess_exception& ex) { isMsmAvailable = false; logger->log_p(L"SharedMemoryUtils::getAccounts (isMsmAvailable = false) interprocess_exception: [%S] native_error=[%d] error_code=[%d]", ex.what(), ex.get_native_error(), ex.get_error_code() ); } catch (...){ isMsmAvailable = false; logger->log(L"SharedMemoryUtils::getAccounts (isMsmAvailable = false) EXCEPTION: unknown"); } //TODO problems with this catch if(isMsmAvailable){ for (int recordNo = 0; recordNo < SMUCONST_MSM_RECORDS_COUNT; recordNo++ ){ boost::interprocess::mapped_region region1( *msm, boost::interprocess::read_only, SMUCONST_MSM_HEADER_SIZE + (recordNo * SMUCONST_MSM_RECORD_SIZE) + SMUCONST_MSM_RECORD_TYPE_RECOFFSET, SMUCONST_MSM_RECORD_TYPE_SIZE ); char* recordTypePtr = static_cast<char*>(region1.get_address()); if (*recordTypePtr == 'A'){ //Account AccountClass* accountInstance = new AccountClass(); boost::interprocess::mapped_region region2( *msm, boost::interprocess::read_only, SMUCONST_MSM_HEADER_SIZE + (recordNo * SMUCONST_MSM_RECORD_SIZE) + SMUCONST_MSM_RECORD_DNAME_RECOFFSET, SMUCONST_MSM_RECORD_DNAME_SIZE ); wchar_t* displayNamePtr = static_cast<wchar_t*>(region2.get_address()); accountInstance->displayName = displayNamePtr; boost::interprocess::mapped_region region3( *msm, boost::interprocess::read_only, SMUCONST_MSM_HEADER_SIZE + (recordNo * SMUCONST_MSM_RECORD_SIZE) + SMUCONST_MSM_RECORD_HANDLE_RECOFFSET, SMUCONST_MSM_RECORD_HANDLE_SIZE ); uint64_t* agcHandlePtr = static_cast<uint64_t*>(region3.get_address()); accountInstance->handle = *agcHandlePtr; accountsListPtr->push_back(accountInstance); foundAccountsCount++; } //TODO - set all records to type 'E'Empty - if E break for } //end for //check SMUCONST_MSM_HEADER_ISLAST_OFFSET boost::interprocess::mapped_region region4( *msm, boost::interprocess::read_only, SMUCONST_MSM_HEADER_ISLAST_OFFSET, SMUCONST_MSM_HEADER_ISLAST_SIZE ); char* isLastNodePtr = static_cast<char*>(region4.get_address()); if (*isLastNodePtr == '1'){ isMsmAvailable = false; logger->log(L"SharedMemoryUtils::getAccounts - isLastNodePtr - isMsmAvailable = false"); } }// end if } while (isMsmAvailable); logger->log_p(L"SharedMemoryUtils::getAccounts return foundAccountsCount = %d", foundAccountsCount); return foundAccountsCount; }
int main(void) { volatile int * (cam_start) = (int *)CAM_START; // Output volatile int * (sdram_data1) = (int *)SDRAM_DATA1; //Input volatile int * (sdram_read) = (int *)READ_OUT_ADDR; //Output volatile int * (read_good) = (int *)VGA_CLK_IN; //Input volatile int * (sdram_reset) = (int *)VGA_DATA1; //Output volatile int * (vga_reset) = (int *)VGA_DATA2; //Output volatile int *(clock_select) = (int *)SOURCE_SELECT; volatile int *(clock_gen) = (int *)CONTROLLING_CLK; volatile int *nn_write_data_1 = (int *)NN_WRITE_DATA_1; volatile int *nn_write_data_2 = (int *)NN_WRITE_DATA_2; volatile int *nn_write_enable = (int *)NN_WRITE_ENABLE; volatile int *nn_write_clock = (int *)NN_WRITE_CLOCK; volatile int *nn_read_enable = (int *)NN_READ_ENABLE; volatile int *nn_read_clock = (int *)NN_READ_CLOCK; volatile int *nn_bootup = (int *)NN_BOOTUP; volatile int *nn_access = (int *)NN_ACCESS; volatile int *nn_read_data_1 = (int *)NN_READ_DATA_1; volatile int *nn_read_data_2 = (int *)NN_READ_DATA_2; int16_t number1, number2; *cam_start = 0; *nn_write_clock = 0; *nn_read_clock = 0; *nn_bootup = 1; *sdram_reset = 1; // reset signals to set read address *sdram_reset = 0; *sdram_reset = 1; *nn_write_enable = 1; int i = 0; // WRITING // finalW1L1 /* for (int i = 0; i < 200; i++) { for (int j = 0; j < 784/4; j = j + 4) { number1 = (finalW1L1[i][j] << 8) | (finalW1L1[i][j+1] & 0xff); number2 = (finalW1L1[i][j+2] << 8) | (finalW1L1[i][j+3] & 0xff); *nn_write_data_1 = number1; *nn_write_data_2 = number2; *nn_write_clock = 1; *nn_write_clock = 0; } } // finalW1L1 // finalB1L1 for (int i = 0; i < 200/4; i = i + 4) { number1 = (finalB1L1[i] << 8) | (finalB1L1[i+1] & 0xff); number2 = (finalB1L1[i+2] << 8) | (finalB1L1[i+3] & 0xff); *nn_write_data_1 = number1; *nn_write_data_2 = number2; *nn_write_clock = 1; *nn_write_clock = 0; } // finalB1L1 // finalW1L2 for (int i = 0; i < 200; i++) { for (int j = 0; j < 200/4; j = j + 4) { number1 = (finalW1L2[i][j] << 8) | (finalW1L2[i][j+1] & 0xff); number2 = (finalW1L2[i][j+2] << 8) | (finalW1L2[i][j+3] & 0xff); *nn_write_data_1 = number1; *nn_write_data_2 = number2; *nn_write_clock = 1; *nn_write_clock = 0; } } // finalW1L2 // finalB1L2 for (int i = 0; i < 200/4; i = i + 4) { number1 = (finalW1L2[i] << 8) | (finalW1L2[i+1] & 0xff); number2 = (finalW1L2[i+2] << 8) | (finalW1L2[i+3] & 0xff); *nn_write_data_1 = number1; *nn_write_data_2 = number2; *nn_write_clock = 1; *nn_write_clock = 0; } // finalB1L2 // finalSoftmaxTheta for (int i = 0; i < 10; i++) { for (int j = 0; j < 200/4; j = j + 4) { number1 = (finalW1L2[i][j] << 8) | (finalW1L2[i][j+1] & 0xff); number2 = (finalW1L2[i][j+2] << 8) | (finalW1L2[i][j+3] & 0xff); *nn_write_data_1 = number1; *nn_write_data_2 = number2; *nn_write_clock = 1; *nn_write_clock = 0; } } // finalSoftmaxTheta */ for (i = 0; i < 20; i = i + 2) { number1 = 1; number2 = 2; *nn_write_data_1 = number1; *nn_write_data_2 = number2; *nn_write_clock = 1; *nn_write_clock = 0; } // READING *nn_access = 1; *nn_read_enable = 1; *sdram_reset = 0; // reset sdram *sdram_reset = 1; int8_t testRead1, testRead2; for (i = 0; i < 20; i = i + 2) { number1 = *nn_read_data_1; number2 = *nn_read_data_2; *nn_read_clock = 1; *nn_read_clock = 0; printf("%d\t", number1); printf("%d\n", number2); } *nn_write_enable = 0; *nn_bootup = 0; *nn_read_enable = 0; *nn_access = 0; int M; //int i = 0; int j = 0; int k = 0; int L = 0; int snapshot = 0; *nn_bootup = 0; *nn_access = 0; *sdram_reset = 0; *sdram_reset = 1; *vga_reset = 1; *clock_select = 0; int write_data = 0; int written = 0; int height = HEIGHT, width = WIDTH; int** black_white = (int**)malloc(HEIGHT*sizeof(int*)); for (i = 0; i < HEIGHT; i++) { black_white[i] = (int*)malloc(sizeof(int)*WIDTH); } while (1){ *cam_start = 1; totalCycles = 0; printf("Press enter to start\n"); fflush(stdin); getchar(); fflush(stdin); // delay before capture for (i = 0; i < 30000; i++) { } snapshot = 1; if (snapshot) { // // int cycleCounter = 0; // int cycleIndex = 0; initCounters(); main_1 = getCycles(); *cam_start = 0; // pause camera *clock_select = 1; // choose custom clock from hps *sdram_reset = 0; // reset sdram *sdram_reset = 1; *sdram_read = 1; // set read request to high // // main_2 = getCycles(); // clear out first horizontal row, it is all black for (k = 0; k < WIDTH + 3; k = k + 1) { *clock_gen = 1; // generate 4 clock cycles to move slower clock 1 cycle *clock_gen = 0; *clock_gen = 1; *clock_gen = 0; } // // main_3 = getCycles(); // begin reading in data for (j = 0; j < HEIGHT; j = j + 1) { for (k = 0; k < WIDTH; k = k + 1) { for (L = 0; L < 2; L = L + 1) { *clock_gen = 1; // generate 4 clock cycles, checking each cycle if (!written) { if (*read_good) // take in data from verilog to read block (not sure if needed) { black_white[j][k] = *(sdram_data1); written = 1; } } *clock_gen = 0; } written = 0; } *sdram_read = 0; *sdram_read = 1; /* // if (cycleCounter == 48) { cycleCounter = 0; cycle[cycleIndex] = getCycles(); cycleIndex++; } */ } // // main_3 = getCycles(); *sdram_read = 0; *sdram_reset = 0; *vga_reset = 0; *sdram_reset = 1; *vga_reset = 1; *cam_start = 1; *clock_select = 0; snapshot = 0; //printf("Done\n"); } // main_4 = getCycles(); height = HEIGHT; width = WIDTH; printf("Image = %d x %d\n", height, width); printf("\n\n"); for (i = 0; i < height; i++) { for (k = 0; k < width; k++) { printf("%d\t", black_white[i][k]); } printf("\n"); }/**/ //printf("Total Image = %d %d\n",height, width); region_1 = getCycles(); region2(&width, &height, black_white); region_end = getCycles(); /* printf("ROI = %d x %d\n",height, width); printf("\n\n"); for (i = 0; i < height; i++) { for (k = 0; k < width; k++) { printf("%d\t",black_white[i][k]); } printf("\n"); } /* */ //printf("Region Found\n\n"); digit_separate2(height, width, black_white); //separate_end = getCycles(); rec_2 = getCycles(); printf("Done\n"); /* for (i = 0; i < 10; i++) printf("%d:\t %u\n",i+1,cycle[i]); */ // printf("\n1: \t%d\n2: \t%d\n3: \t%d\n4: \n5: \n6: \t%d\n7: \t%d\n", main_1, main_2, main_3, main_6, main_7); final = (main_4 - main_1); // printf("\nTimes:\nMain: \t%d\n\n", final); totalCycles += final; final = (region_end - region_1);
double region3(double x, double *p){ return (p[7]*x + p[8]*x*x + region2(p[17]-p[16],p) ); }
int SharedMemoryUtils::getClientInstances(boost::ptr_list<ClientInstanceClass> * clientInstancesListPtr, std::wstring& forThisProfileName) { if (clientInstancesListPtr==NULL){ logger->log(L"SharedMemoryUtils::getClientInstances clientInstancesListPtr==NULL"); return -1; } int count = 0; for (int recordNo = 0; recordNo < SMUCONST_CSM_RECORDS_COUNT; recordNo++ ){ boost::interprocess::mapped_region region1( *csm, boost::interprocess::read_only, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_STATUS_RECOFFSET, SMUCONST_CSM_RECORD_STATUS_SIZE ); char* recordStatusPtr = static_cast<char*>(region1.get_address()); if (*recordStatusPtr == 'W'){ boost::interprocess::mapped_region region2( *csm, boost::interprocess::read_only, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_TYPE_RECOFFSET, SMUCONST_CSM_RECORD_TYPE_SIZE ); char* recordTypePtr = static_cast<char*>(region2.get_address()); if (*recordTypePtr == 'M'){ boost::interprocess::mapped_region region3( *csm, boost::interprocess::read_only, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_VISABLETO_RECOFFSET, SMUCONST_CSM_RECORD_VISABLETO_SIZE ); wchar_t* recordVisabletoPtr = static_cast<wchar_t*>(region3.get_address()); std::wstring visableTo = recordVisabletoPtr; if (isTokenOnList(forThisProfileName, visableTo)){ //this instance match all conditions //get its name and id (recordNo) ClientInstanceClass* clientInstance = new ClientInstanceClass(); boost::interprocess::mapped_region region4( *csm, boost::interprocess::read_write, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_RECID_RECOFFSET, SMUCONST_CSM_RECORD_RECID_SIZE ); uint16_t* recordIdPtr = static_cast<uint16_t*>(region4.get_address()); clientInstance->recordId = *recordIdPtr; boost::interprocess::mapped_region region5( *csm, boost::interprocess::read_only, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_DNAME_RECOFFSET, SMUCONST_CSM_RECORD_DNAME_SIZE ); wchar_t* displayNamePtr = static_cast<wchar_t*>(region5.get_address()); clientInstance->displayName = displayNamePtr; clientInstancesListPtr->push_back(clientInstance); count++; } }//end if M }//end if W }//end for logger->log_p(L"SharedMemoryUtils::getClientInstances return count = %d", count); return count; }
int main() { srand(time(NULL)); int WIDTH(750), HEIGHT(750); sf::RenderWindow window(sf::VideoMode(WIDTH, HEIGHT), "RTest"); window.setFramerateLimit(60); RegionMap world(100, 80); Region *region1(nullptr), *region2(nullptr); std::vector<Region*> path; double offsetX = 0; sf::Vector2i clicPos; sf::Transform slide, loopSlide; while (window.isOpen()) { sf::Vector2i localPosition = sf::Mouse::getPosition(window); sf::Event event; while (window.pollEvent(event)) { if (event.type == sf::Event::Closed) { window.close(); } else if (event.type == sf::Event::MouseButtonPressed) { clicPos = localPosition; } } if (sf::Mouse::isButtonPressed(sf::Mouse::Left)) { region1 = world.getRegionAt(localPosition.x, localPosition.y); int move = localPosition.x-clicPos.x; offsetX += move; slide.translate(sf::Vector2f(move, 0)); if (offsetX > 0) loopSlide.translate(sf::Vector2f(move-WIDTH, 0)); else loopSlide.translate(sf::Vector2f(move+WIDTH, 0)); clicPos = localPosition; } Region* newRegion2 = world.getRegionAt(localPosition.x, localPosition.y); if (newRegion2 != region2 && newRegion2) { region2 = newRegion2; path = world.getRoute(region1, region2); } sf::VertexArray routes(sf::Lines, 0); if (path.size()) { for (unsigned int i(0); i<path.size()-1; ++i) { unsigned int x = path[i]->capital()._x; unsigned int y = path[i]->capital()._y; sf::Vertex routePoint; routePoint.position = sf::Vector2f(x, y); routePoint.color = sf::Color::Red; routes.append(routePoint); routePoint.position = sf::Vector2f(path[i+1]->capital()._x, path[i+1]->capital()._y); routePoint.color = sf::Color::Red; routes.append(routePoint); } } window.clear(sf::Color::White); world.render(&window, slide); window.draw(routes, slide); window.draw(routes, loopSlide); window.display(); } return 0; }
/** * * return * >0 - id of assigned record * -1 - no empty record found */ uint16_t SharedMemoryUtils::allocateRecordInCsm(boost::interprocess::windows_shared_memory& csm, char type, std::wstring& displayName, std::wstring& visableTo, bool doCommitSM) { //try to find first record with status E (Empty) in CSM for (unsigned short recordNo = 0; recordNo < SMUCONST_CSM_RECORDS_COUNT; recordNo++ ){ boost::interprocess::mapped_region region1( csm, boost::interprocess::read_write, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_STATUS_RECOFFSET, SMUCONST_CSM_RECORD_STATUS_SIZE ); char* recordStatusPtr = static_cast<char*>(region1.get_address()); if (*recordStatusPtr == 'E'){ //save new status 'N' (New) *recordStatusPtr = 'N'; //save type boost::interprocess::mapped_region region2( csm, boost::interprocess::read_write, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_TYPE_RECOFFSET, SMUCONST_CSM_RECORD_TYPE_SIZE ); char* recordTypePtr = static_cast<char*>(region2.get_address()); *recordTypePtr = type; //save first keep alive timestamp boost::interprocess::mapped_region region3( csm, boost::interprocess::read_write, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_KAT_RECOFFSET, SMUCONST_CSM_RECORD_KAT_SIZE ); time_t* recordKatPtr = static_cast<time_t*>(region3.get_address()); *recordKatPtr = mfGetCurrentTimestamp(); //save version boost::interprocess::mapped_region region4( csm, boost::interprocess::read_write, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_VERSION_RECOFFSET, SMUCONST_CSM_RECORD_VERSION_SIZE ); uint16_t* recordVersionPtr = static_cast<uint16_t*>(region4.get_address()); *recordVersionPtr = SMUCONST_CSM_CURRENT_RECORDVERSION; //save display name boost::interprocess::mapped_region region5( csm, boost::interprocess::read_write, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_DNAME_RECOFFSET, SMUCONST_CSM_RECORD_DNAME_SIZE ); wchar_t* recordDnamePtr = static_cast<wchar_t*>(region5.get_address()); wcsncpy_s(recordDnamePtr, SMUCONST_CSM_RECORD_DNAME_SIZEC, displayName.c_str(), _TRUNCATE); //save visableTo boost::interprocess::mapped_region region6( csm, boost::interprocess::read_write, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_VISABLETO_RECOFFSET, SMUCONST_CSM_RECORD_VISABLETO_SIZE ); wchar_t* recordVisabletoPtr = static_cast<wchar_t*>(region6.get_address()); wcsncpy_s(recordVisabletoPtr, SMUCONST_CSM_RECORD_VISABLETO_SIZEC, visableTo.c_str(), _TRUNCATE); //get id boost::interprocess::mapped_region region7( csm, boost::interprocess::read_write, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_RECID_RECOFFSET, SMUCONST_CSM_RECORD_RECID_SIZE ); uint16_t* recordIdPtr = static_cast<uint16_t*>(region7.get_address()); if (doCommitSM){ *recordStatusPtr = 'W'; } logger->log_p(L"allocateRecordInCsm: allocated record with id (processCsmId): %u", *recordIdPtr); return *recordIdPtr; }//end if }//end for logger->log(L"allocateRecordInCsm: no empty records in CSM. return -1"); return -2; }
int SharedMemoryUtils::addRecordToMsm(char type, uint64_t agcHandle, uint64_t accountHandle, uint64_t groupHandle, char status, std::wstring& value) { logger->log_p(L"addRecordToMsm: type=[%c], agcHandle=[%I64u], accountHandle=[%I64u], groupHandle=[%I64u], status=[%c], value=[%s], agcHandle=[%I64u]", type, agcHandle, accountHandle, groupHandle, status==NULL?'-':status , value.c_str(), agcHandle); //if there is not enought space in current msm - create new one if (freeMsmRecordsCount == 0){ std::size_t msmTotalSize = getMsmTotalSize(); std::string msmName = getMsmName(processCsmId, nextMsmNumber); logger->log_p(L"create new MSM msmName=[%S] " SCNuPTR L" Bytes (schould be 32768 B)", msmName.c_str(), msmTotalSize); boost::interprocess::windows_shared_memory* msm; msm = new boost::interprocess::windows_shared_memory( boost::interprocess::open_or_create, msmName.c_str(), boost::interprocess::read_write, msmTotalSize ); //TODO exception handling //TODO delete msm //zero shared memory (neccessery if sm was opened(it is old wrong msm from deleted miranda msm record so it contains old bad data)) boost::interprocess::mapped_region regionToDel( *msm, boost::interprocess::read_write, 0, msmTotalSize ); memset(regionToDel.get_address(), 0, msmTotalSize); //set isLastNodePtr initial value to 0 , will be update at commitCSM() boost::interprocess::mapped_region region1( *msm, boost::interprocess::read_write, SMUCONST_MSM_HEADER_ISLAST_OFFSET, SMUCONST_MSM_HEADER_ISLAST_SIZE ); char* isLastNodePtr = static_cast<char*>(region1.get_address()); *isLastNodePtr = '0'; //TODO - set all records to type 'E'Empty msmList.push_back(msm); nextMsmNumber++; freeMsmRecordsCount = SMUCONST_MSM_RECORDS_COUNT; } boost::interprocess::windows_shared_memory * currentMsm = &(msmList.back()); //save data to record int actualRecordOffset = SMUCONST_MSM_RECORDS_OFFSET + ((SMUCONST_MSM_RECORDS_COUNT - freeMsmRecordsCount) * SMUCONST_MSM_RECORD_SIZE); //char type boost::interprocess::mapped_region region1( *currentMsm, boost::interprocess::read_write, actualRecordOffset + SMUCONST_MSM_RECORD_TYPE_RECOFFSET, SMUCONST_MSM_RECORD_TYPE_SIZE ); char* recordTypePtr = static_cast<char*>(region1.get_address()); *recordTypePtr = type; //HANDLE agcHandle boost::interprocess::mapped_region region2( *currentMsm, boost::interprocess::read_write, actualRecordOffset + SMUCONST_MSM_RECORD_HANDLE_RECOFFSET, SMUCONST_MSM_RECORD_HANDLE_SIZE ); uint64_t* agcHandlePtr = static_cast<uint64_t*>(region2.get_address()); *agcHandlePtr = agcHandle; //HANDLE accountHandle boost::interprocess::mapped_region region3( *currentMsm, boost::interprocess::read_write, actualRecordOffset + SMUCONST_MSM_RECORD_ACCOUNTH_RECOFFSET, SMUCONST_MSM_RECORD_ACCOUNTH_SIZE ); uint64_t* accountHandlePtr = static_cast<uint64_t*>(region3.get_address()); *accountHandlePtr = accountHandle; //HANDLE groupHandle boost::interprocess::mapped_region region4( *currentMsm, boost::interprocess::read_write, actualRecordOffset + SMUCONST_MSM_RECORD_GROUPH_RECOFFSET, SMUCONST_MSM_RECORD_GROUPH_SIZE ); uint64_t* groupHandlePtr = static_cast<uint64_t*>(region4.get_address()); *groupHandlePtr = groupHandle; //char status boost::interprocess::mapped_region region5( *currentMsm, boost::interprocess::read_write, actualRecordOffset + SMUCONST_MSM_RECORD_STATUS_RECOFFSET, SMUCONST_MSM_RECORD_STATUS_SIZE ); char* recordStatusPtr = static_cast<char*>(region5.get_address()); *recordStatusPtr = status; //std::wstring& value boost::interprocess::mapped_region region6( *currentMsm, boost::interprocess::read_write, actualRecordOffset + SMUCONST_MSM_RECORD_DNAME_RECOFFSET, SMUCONST_MSM_RECORD_DNAME_SIZE ); wchar_t* recordValuePtr = static_cast<wchar_t*>(region6.get_address()); wcsncpy_s(recordValuePtr, SMUCONST_MSM_RECORD_DNAME_SIZEC, value.c_str(), _TRUNCATE); freeMsmRecordsCount --; return 0; }
//recordNo === processCsmId -1 void SharedMemoryUtils::freeCsmRecord(boost::interprocess::windows_shared_memory& csm, uint16_t recordNo) { logger->log_p(L"freeCsmRecord: recordNo = %u processCsmId = %u", recordNo, recordNo+1); //zero type boost::interprocess::mapped_region region1( csm, boost::interprocess::read_write, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_TYPE_RECOFFSET, SMUCONST_CSM_RECORD_TYPE_SIZE ); char* recordTypePtr = static_cast<char*>(region1.get_address()); *recordTypePtr = (char)0; //zero keepalive timestamp boost::interprocess::mapped_region region2( csm, boost::interprocess::read_write, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_KAT_RECOFFSET, SMUCONST_CSM_RECORD_KAT_SIZE ); time_t* recordKatPtr = static_cast<time_t*>(region2.get_address()); *recordKatPtr = (time_t)0; //zero msm timestamp boost::interprocess::mapped_region region3( csm, boost::interprocess::read_write, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_MSMT_RECOFFSET, SMUCONST_CSM_RECORD_MSMT_SIZE ); time_t* recordMsmtPtr = static_cast<time_t*>(region3.get_address()); *recordMsmtPtr = (time_t)0; //zero displayname boost::interprocess::mapped_region region4( csm, boost::interprocess::read_write, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_DNAME_RECOFFSET, SMUCONST_CSM_RECORD_DNAME_SIZE ); memset(region4.get_address(), 0, SMUCONST_CSM_RECORD_DNAME_SIZE); //zero visableto boost::interprocess::mapped_region region5( csm, boost::interprocess::read_write, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_VISABLETO_RECOFFSET, SMUCONST_CSM_RECORD_VISABLETO_SIZE ); memset(region5.get_address(), 0, SMUCONST_CSM_RECORD_VISABLETO_SIZE); //status = E boost::interprocess::mapped_region region6( csm, boost::interprocess::read_write, SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_STATUS_RECOFFSET, SMUCONST_CSM_RECORD_STATUS_SIZE ); char* recordStatusPtr = static_cast<char*>(region6.get_address()); *recordStatusPtr = 'E'; }
int GeometryClipmaps::updateLevel( GeometryClipmapLevel& level, GeometryClipmapLevel* parentLevel, const Pnt2i& newOrigin ) { //todo: move this into the GeometryClipmapLevel class?? // how much samples do we have to update? const Pnt2i oldOrigin = level.sampleOrigin; const Pnt2i updateSampleCount = newOrigin - oldOrigin; const bool forceFullUpdate = level.isSampleDataDirty; if( !forceFullUpdate && oldOrigin == newOrigin ) { // nothing to do: return 0; } //SLOG << "Level " << level.index << " moved by " << updateSampleCount << " oldOrigin = " << oldOrigin << " newOrigin = " << newOrigin << "\n"; // whatever we need to do: the origin is now here: level.sampleOrigin = newOrigin; const int levelSampleCount = level.heightmap.size; const int levelSampleSpacing = level.sampleSpacing; const bool fullBlockUpdate = ( abs( updateSampleCount[ 0 ] ) >= levelSampleCount ) || ( abs( updateSampleCount[ 1 ] ) >= levelSampleCount ); int updatedSampleCount = 0; if( fullBlockUpdate || forceFullUpdate ) { // full block update: // reset the block origin: level.blockOrigin.setValues( 0, 0 ); updatedSampleCount += updateLevelBlock( level, parentLevel, Rectangle2i( 0, 0, levelSampleCount, levelSampleCount ) ); } else if( updateSampleCount[ 0 ] != 0 || updateSampleCount[ 1 ] != 0 ) { Pnt2i levelSampleCount2d( levelSampleCount, levelSampleCount ); // adjust adressing.. Pnt2i blockDelta = componentDivide( updateSampleCount, levelSampleSpacing ); Pnt2i oldBlockOrigin( level.blockOrigin[ 0 ], level.blockOrigin[ 1 ] ); // update block origin: Pnt2i newBlockOrigin = componentModulo( componentAdd( componentAdd( oldBlockOrigin, blockDelta ), levelSampleCount2d ), levelSampleCount2d ); assert( newBlockOrigin[ 0 ] >= 0 ); assert( newBlockOrigin[ 1 ] >= 0 ); assert( newBlockOrigin[ 0 ] < levelSampleCount ); assert( newBlockOrigin[ 1 ] < levelSampleCount ); level.blockOrigin = newBlockOrigin; // update the dirty Rects: // in general the update region is ? shaped: (we do 1 or 2 rectangular updates) Rectangle2i region1( 0, 0, levelSampleCount, levelSampleCount ); Rectangle2i region2( 0, 0, levelSampleCount, levelSampleCount ); Rectangle2i region3( 0, 0, levelSampleCount, levelSampleCount ); if( blockDelta[ 0 ] > 0 ) { region1._x0 = oldBlockOrigin[ 0 ]; region1._x1 = region1._x0 + blockDelta[ 0 ]; } else if( blockDelta[ 0 ] < 0 ) { region1._x0 = newBlockOrigin[ 0 ]; region1._x1 = region1._x0 - blockDelta[ 0 ]; } else { // region 1 is empty: region1.setValues( 0, 0, 0, 0 ); } if( blockDelta[ 1 ] > 0 ) { region2._y0 = oldBlockOrigin[ 1 ]; region2._y1 = region2._y0 + blockDelta[ 1 ]; } else if( blockDelta[ 1 ] < 0 ) { region2._y0 = newBlockOrigin[ 1 ]; region2._y1 = region2._y0 - blockDelta[ 1 ]; } else { // region 1 is empty: region2.setValues( 0, 0, 0, 0 ); } updatedSampleCount += updateBigLevelBlock( level, parentLevel, region1 ); updatedSampleCount += updateBigLevelBlock( level, parentLevel, region2 ); } // for debugging: //checkLevelBlock( level, Rectangle2i( 0, 0, levelSampleCount, levelSampleCount ) ); cpuRenderer_.rebuildIndices( level ); if( parentLevel ) { // todo: is this really needed every frame? cpuRenderer_.rebuildIndices( *parentLevel ); } // determine min/max sample: level.heightmap.updateMinMaxSamples(); // activate this level: level.isActive = true; // we just updated the data: level.isSampleDataDirty = false; // todo: make this work: return updatedSampleCount; //return 0; }