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;
}
