コード例 #1
0
void mmSynchronize::mmReadWriteLockCSWindows::LockForWrite(void)
{
	SendLogMessage(mmLog::debug,mmString(L"Start LockForWrite"));

	bool v_bIsLocked = false;

	while(!v_bIsLocked)
	{
		m_psExclusiveLock->Lock();
			if(m_iReadWriteCount == 0)
			{
				m_iReadWriteCount = -1;
				v_bIsLocked = true;
			}
			else
			{
				if( (m_iReadWriteCount > 0) && (!m_bWaitForWriteLock) )
				{
					m_bWaitForWriteLock = true;
				};
			};
		m_psExclusiveLock->Unlock();

		if(!v_bIsLocked)
		{
			Sleep(1);
		};
	};

	SendLogMessage(mmLog::debug,mmString(L"End LockForWrite LockCount=") +
															mmStringUtilities::MMIntToString(m_iReadWriteCount));
}
コード例 #2
0
void mmSynchronize::mmReadWriteLockCSWindows::UnlockFromWrite(void)
{
	SendLogMessage(mmLog::debug,mmString(L"Start UnlockFromWrite"));

	bool v_bIsReadWriteLockDeSynchronized = false;

	m_psExclusiveLock->Lock();
		if(m_iReadWriteCount == -1)
		{
			m_iReadWriteCount = 0;
			m_bWaitForWriteLock = false;
		}
		else
		{
			v_bIsReadWriteLockDeSynchronized = true;
		};
	m_psExclusiveLock->Unlock();

	if(v_bIsReadWriteLockDeSynchronized)
	{
		SendLogMessage(mmLog::critical,mmString(L"UnlockFromWrite TooManyUnlocksFromWrite"));

		throw mmError(mmeReadWriteLockWriteUnlocked);
	};

	SendLogMessage(mmLog::debug,mmString(L"End UnlockFromWrite LockCount=") +
															mmStringUtilities::MMIntToString(m_iReadWriteCount));
}
コード例 #3
0
void mmThread::mmThreadWindows::ThreadExecute(void)
{
	SendLogMessage(mmLog::debug,mmString(L"Start ThreadExecute"));


	CoInitializeEx(NULL,COINIT_MULTITHREADED);
	bool v_bIsCalculated = m_psThreadExecutionClass->Execute();
	CoUninitialize();

	m_psExclusiveLock->Lock();
		if(v_bIsCalculated)
		{
			m_eThreadStatus = finished;
			SendLogMessage(mmLog::debug,mmString(L"ThreadExecute Status=finished"));
		}
		else
		{
			m_eThreadStatus = stopped;
			SendLogMessage(mmLog::debug,mmString(L"ThreadExecute Status=stopped"));
		};

		// to wywo³anie jest w sekcji krytycznej dlatego, ¿e czêsto po tej metodzie
		// wywo³uje siê destruktora i wtedy to wywo³anie jest ju¿ w nie istniej¹cym
    // obiekcie
		SendLogMessage(mmLog::debug,mmString(L"End ThreadExecute"));

	m_psExclusiveLock->Unlock();
}
コード例 #4
0
ファイル: mmCalcMethod.cpp プロジェクト: ogx/Calculation2D
//---------------------------------------------------------------------------
void mmImages::mmCalcMethod::StopExecution(void)
{
	SendLogMessage(mmLog::debug,mmString(L"Start StopExecution"));

	m_bStopExecution = true;

	SendLogMessage(mmLog::debug,mmString(L"End StopExecution"));
}
コード例 #5
0
ファイル: mmCalcMethod.cpp プロジェクト: ogx/Calculation2D
//---------------------------------------------------------------------------
bool mmImages::mmCalcMethod::IsExecuting(void)
{
	SendLogMessage(mmLog::debug,mmString(L"Start IsExecuting"));

	SendLogMessage(mmLog::debug,mmString(L"End IsExecuting"));

	return m_bIsExecuting;
}
コード例 #6
0
void mmSynchronize::mmExclusiveLockCSWindows::Unlock(void)
{
	SendLogMessage(mmLog::debug,mmString(L"Start Unlock"));

	::LeaveCriticalSection(&m_sCriticalSection);

	SendLogMessage(mmLog::debug,mmString(L"End Unlock"));
}
コード例 #7
0
mmThread::mmThreadI::eStatus mmThread::mmThreadWindows::GetStatus(void)
{
//	SendLogMessage(mmLog::debug,mmString(L"Start GetStatus"));

	eStatus v_eTempStat;

	m_psExclusiveLock->Lock();
		v_eTempStat = m_eThreadStatus;
	m_psExclusiveLock->Unlock();

	mmString v_sStatusString;

	switch(v_eTempStat)
	{
		case created:
		{
			v_sStatusString = L"created";
		};
		break;
		case initialized:
		{
			v_sStatusString = L"initialized";
		};
		break;
		case running:
		{
			v_sStatusString = L"running";
		};
		break;
		case stopping:
		{
			v_sStatusString = L"stopping";
		};
		break;
		case stopped:
		{
			v_sStatusString = L"stopped";
		};
		break;
		case finished:
		{
			v_sStatusString = L"finished";
		};
		break;
		default:
		{
			SendLogMessage(mmLog::critical,mmString(L"GetStatus UnknownThreadState"));

			throw mmError(mmeThreadUnknownThreadState);
		};
	};

	SendLogMessage(mmLog::debug,mmString(L"End GetStatus Status=")+
															v_sStatusString);

	return v_eTempStat;
}
コード例 #8
0
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////  mmSynchronize::mmExclusiveLockCSWindows
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
mmSynchronize::mmExclusiveLockCSWindows::mmExclusiveLockCSWindows(mmLog::mmLogReceiverI *p_psLogReceiver):
																					 mmLog::mmLogSender(L"mmSynchronize::mmExclusiveLockCSWindows",p_psLogReceiver)
{
	SendLogMessage(mmLog::debug,mmString(L"Start Constructor"));

	::InitializeCriticalSectionAndSpinCount(&m_sCriticalSection, 300);

	SendLogMessage(mmLog::debug,mmString(L"End Constructor"));
}
コード例 #9
0
ファイル: mmCalcMethod.cpp プロジェクト: ogx/Calculation2D
//---------------------------------------------------------------------------
bool mmImages::mmCalcMethod::Execute(void)
{
	SendLogMessage(mmLog::debug,mmString(L"Start Execute"));

	bool v_bResult = Calculate();

	SendLogMessage(mmLog::debug,mmString(L"End Execute"));

	return v_bResult;
}
コード例 #10
0
ファイル: mmCalcMethod.cpp プロジェクト: ogx/Calculation2D
mmImages::mmImagesCalculationMethodI::sCalculationMethodParams mmImages::mmCalcMethod::GetCalculationMethodInfo(void)
{
	SendLogMessage(mmLog::debug,mmString(L"Start GetCalculationMethodInfo"));

	// serialize parameters
	SerializeParameters();

	SendLogMessage(mmLog::debug,mmString(L"End GetCalculationMethodInfo"));

	return m_sCMParams;
}
コード例 #11
0
ファイル: mmCalcMethod.cpp プロジェクト: ogx/Calculation2D
//---------------------------------------------------------------------------
mmImages::mmCalcMethod::~mmCalcMethod()
{
	SendLogMessage(mmLog::debug,mmString(L"Start Destructor"));
	
	for(std::list<mmGenericParamI*>::iterator v_sParam = m_sInputParams.begin(); v_sParam != m_sInputParams.end(); ++v_sParam)
		delete *v_sParam;

	for(std::list<mmGenericParamI*>::iterator v_sParam = m_sOutputParams.begin(); v_sParam != m_sOutputParams.end(); ++v_sParam)
		delete *v_sParam;

	SendLogMessage(mmLog::debug,mmString(L"End Destructor"));
}
コード例 #12
0
mmSynchronize::mmExclusiveLockCSWindows::~mmExclusiveLockCSWindows()
{
	SendLogMessage(mmLog::debug,mmString(L"Start Destructor"));

	if(m_sCriticalSection.LockCount > -1)
	{
		SendLogMessage(mmLog::critical,mmString(L"Destructor Locked"));

		throw mmError(mmeExclusiveLockLocked);
	};

	::DeleteCriticalSection(&m_sCriticalSection);

	SendLogMessage(mmLog::debug,mmString(L"End Destructor"));
}
コード例 #13
0
bool mmSynchronize::mmExclusiveLockCSWindows::TryLock(void)
{
	bool v_bIsLocked = true;

	SendLogMessage(mmLog::debug,mmString(L"Start TryLock"));

	if(::TryEnterCriticalSection(&m_sCriticalSection) == 0)
	{
		v_bIsLocked = false;
	};

	SendLogMessage(mmLog::debug,mmString(L"End TryLock Locked=") + mmStringUtilities::BoolToString(v_bIsLocked));

	return v_bIsLocked;
}
コード例 #14
0
ファイル: ApiLog.cpp プロジェクト: valery-barysok/Far-NetBox
void CApiLog::LogMessage(CString SourceFile, int nSourceLine, void *pInstance, int nMessageType, LPCTSTR pMsgFormat, ...) const
{
	ASSERT(nMessageType>=4 && nMessageType<=8);
	ASSERT(m_hTargetWnd || m_pApiLogParent);
	ASSERT(nSourceLine>0);


	int pos=SourceFile.ReverseFind(_MPT('\\'));
	if (pos!=-1)
		SourceFile=SourceFile.Mid(pos+1);

	va_list ap;
    
	va_start(ap, pMsgFormat);
	CString text;
	text.FormatV(pMsgFormat, ap);
	va_end(ap);

#ifdef MPEXT
	if (nMessageType>=FZ_LOG_DEBUG)
		return;
#endif

	CString msg;
	msg.Format(_T("%s(%d): %s   caller=0x%08x"), (LPCTSTR)SourceFile, nSourceLine, (LPCTSTR)text, (int)this);
	
	SendLogMessage(nMessageType, msg);
}
コード例 #15
0
mmReal mmThread::mmThreadWindows::GetProgress(void)
{
	mmReal v_rProgress = -1.0;

	SendLogMessage(mmLog::debug,mmString(L"Start GetProgress"));

	m_psExclusiveLock->Lock();
	if(m_eThreadStatus == running)
	{
		v_rProgress = m_psThreadExecutionClass->GetProgress();
	};
	m_psExclusiveLock->Unlock();

	SendLogMessage(mmLog::debug,mmString(L"End GetProgress"));

	return v_rProgress;
}
コード例 #16
0
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////  mmThreads::mmThreadWindows
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
mmThread::mmThreadWindows::mmThreadWindows(mmLog::mmLogReceiverI *p_psLogReceiver):
																					 mmLog::mmLogSender(L"mmThread::mmThreadWindows",p_psLogReceiver)
{
	mmInt v_iTemp;

	SendLogMessage(mmLog::debug,mmString(L"Start Constructor"));

	try
	{
		//m_psExclusiveLock = mmInterfaceInitializers::CreateExclusiveLock(p_psLogReceiver);
		m_psExclusiveLock = mmInterfaceInitializers::CreateExclusiveLock(NULL);
	}
	catch(mmError &v_sErr)
	{
		if(v_sErr.GetErrorCode() == mmeBadAlloc)
    {
			SendLogMessage(mmLog::critical,mmString(L"Constructor ErrorAllocationMemory"));
		};

		throw v_sErr;
	};

	m_hWinThreadHandle = CreateThread(NULL,0,ThreadRedirectFunction,this,CREATE_SUSPENDED,reinterpret_cast<unsigned long*>(&v_iTemp));
	//SetThreadPriority(m_hWinThreadHandle,THREAD_PRIORITY_HIGHEST);

	// jeœli utworzenie nowego w¹tka siê nie powiedzie
	if(m_hWinThreadHandle == NULL)
	{
		delete m_psExclusiveLock;

		SendLogMessage(mmLog::critical,mmString(L"Constructor CreationThreadError"));

		throw mmError(mmeThreadCreateThreadError);
  };

	m_eThreadStatus = created;
	SendLogMessage(mmLog::debug,mmString(L"Constructor Status=created"));

	m_psThreadExecutionClass = NULL;

	SendLogMessage(mmLog::debug,mmString(L"End Constructor PtrToExclusiveLock=") +
															mmStringUtilities::PointerToString(m_psExclusiveLock) +
															mmString(L"; ThreadID=") +
                              mmStringUtilities::MMIntToString(v_iTemp));
}
コード例 #17
0
mmThread::mmThreadWindows::~mmThreadWindows()
{
	SendLogMessage(mmLog::debug,mmString(L"Start Destructor"));

	// zatrzymujê w¹tek
	this->Stop();

	if(WaitForSingleObject(m_hWinThreadHandle,INFINITE) != WAIT_OBJECT_0)
	{
		SendLogMessage(mmLog::critical,mmString(L"Destructor BadStateOfThread"));
	};

	CloseHandle(m_hWinThreadHandle);

	delete m_psExclusiveLock;

	SendLogMessage(mmLog::debug,mmString(L"End Destructor"));
}
コード例 #18
0
ファイル: ApiLog.cpp プロジェクト: elfmz/far2l
void CApiLog::LogMessageRaw(int nMessageType, LPCTSTR pMsg) const
{
  DebugAssert(nMessageType>=FZ_LOG_STATUS && nMessageType<=FZ_LOG_DEBUG);
  if (!LoggingMessageType(nMessageType))
    return;

  if (nMessageType>=FZ_LOG_DEBUG)
    return;
  SendLogMessage(nMessageType, pMsg);
}
コード例 #19
0
mmInt mmSynchronize::mmReadWriteLockCSWindows::GetLockState(bool* p_pbWaitForWrite)
{
	SendLogMessage(mmLog::debug,mmString(L"Start GetLockState"));

	mmInt v_iLockState = m_iReadWriteCount;
	*p_pbWaitForWrite = m_bWaitForWriteLock;

	this->SendLogMessage(mmLog::debug,mmString(L"End GetLockState"));

	return v_iLockState;
}
コード例 #20
0
void mmSynchronize::mmReadWriteLockCSWindows::LockForRead(void)
{
	SendLogMessage(mmLog::debug,mmString(L"Start LockForRead"));

	bool v_bIsLocked = false;

	while(!v_bIsLocked)
	{
		if(TryLockForRead())
		{
			v_bIsLocked = true;
		}
		else
		{
			Sleep(1);
		};
	};

	SendLogMessage(mmLog::debug,mmString(L"End LockForRead LockCount=") +
															mmStringUtilities::MMIntToString(m_iReadWriteCount));
}
コード例 #21
0
bool mmSynchronize::mmReadWriteLockCSWindows::TryLockForWrite(void)
{
	SendLogMessage(mmLog::debug,mmString(L"Start TryLockForWrite"));

	bool v_bIsLocked = false;

	m_psExclusiveLock->Lock();
		if(m_iReadWriteCount == 0)
		{
			m_iReadWriteCount = -1;
			v_bIsLocked = true;
		};
	m_psExclusiveLock->Unlock();

	SendLogMessage(mmLog::debug,mmString(L"End TryLockForWrite LockCount=") +
															mmStringUtilities::MMIntToString(m_iReadWriteCount) +
															mmString(L" Locked=") +
															mmStringUtilities::BoolToString(v_bIsLocked));

	return v_bIsLocked;
}
コード例 #22
0
void mmThread::mmThreadWindows::Run(void)
{
	SendLogMessage(mmLog::debug,mmString(L"Start Run"));

	m_psExclusiveLock->Lock();
	try
	{
		// tylko kiedy w¹tek jest w stanie initialized mo¿e byæ wywo³ywana metoda Run
		if(this->m_eThreadStatus == initialized)
		{
			if(ResumeThread(m_hWinThreadHandle) == 1)
			{
				m_eThreadStatus = running;
				SendLogMessage(mmLog::debug,mmString(L"Run Status=running"));
			}
			else
			{
				SendLogMessage(mmLog::critical,mmString(L"Run ResumeThreadError"));

				throw mmError(mmeThreadResumeError);
			};
		}
		else
    {
			SendLogMessage(mmLog::critical,mmString(L"Run BadThreadStateError"));

			throw mmError(mmeThreadBadThreadState);
    };
  }
	catch(mmError &v_sErr)
	{
		m_psExclusiveLock->Unlock();

		throw v_sErr;
	};

	m_psExclusiveLock->Unlock();

  SendLogMessage(mmLog::debug,mmString(L"End Run"));
}
コード例 #23
0
void mmThread::mmThreadWindows::Stop(void)
{
	SendLogMessage(mmLog::debug,mmString(L"Start Stop"));

	bool bIsCreatedInitializedStoppedOrFinished = false;

	while(!bIsCreatedInitializedStoppedOrFinished)
	{
		m_psExclusiveLock->Lock();
			// w przypadku: kiedy jest uruchomiony ale nie wiadomo czy ju¿ liczy
			if(m_eThreadStatus == running)
			{
				if(m_psThreadExecutionClass->IsExecuting())
				{
					m_eThreadStatus = stopping;
					SendLogMessage(mmLog::debug,mmString(L"Stop Status=stopping"));

					// informujê o zatrzymaniu w¹tka klasê licz¹c¹
					m_psThreadExecutionClass->StopExecution();
				};
			}
			else
			{
				// w innych
				if(m_eThreadStatus != stopping)
				{
					bIsCreatedInitializedStoppedOrFinished = true;
				};
			};
		m_psExclusiveLock->Unlock();

		if(!bIsCreatedInitializedStoppedOrFinished)
		{
			Sleep(1);
		};
	};

	SendLogMessage(mmLog::debug,mmString(L"End Stop"));
}
コード例 #24
0
ファイル: ApiLog.cpp プロジェクト: valery-barysok/Far-NetBox
void CApiLog::LogMessageRaw(int nMessageType, LPCTSTR pMsg) const
{
	ASSERT(nMessageType>=0 && nMessageType<=8);
	ASSERT(m_hTargetWnd || m_pApiLogParent);
	if (nMessageType>=FZ_LOG_APIERROR && (nMessageType-FZ_LOG_APIERROR)>=m_pApiLogParent->m_nDebugLevel)
		return;

#ifdef MPEXT
	if (nMessageType>=FZ_LOG_DEBUG)
		return;
#endif
	SendLogMessage(nMessageType, pMsg);
}
コード例 #25
0
ファイル: mmCalcMethod.cpp プロジェクト: ogx/Calculation2D
mmImages::mmCalcMethod::mmCalcMethod(mmLog::mmLogReceiverI *p_psLogReceiver, mmString p_sClassName) :
	mmLog::mmLogSender(p_sClassName,p_psLogReceiver)
{
	SendLogMessage(mmLog::debug,mmString(L"Start Constructor"));

	swprintf_s(m_sCMParams.sShortName, L"Generic calculation method");
	swprintf_s(m_sCMParams.sIDName, L"{C13390E5-EBA6-404d-8706-B07FFE01C52F}");
	swprintf_s(m_sCMParams.sDescription, L"Generic calculation method");
	m_sCMParams.bIsMultithreaded = true;

	m_psThreadSynchEL.reset(mmInterfaceInitializers::CreateExclusiveLock(NULL));

	m_rProgress = 0.0;
	m_bIsExecuting = false;
	m_bStopExecution = false;

	m_psImageStructure = NULL;

	m_iRowsCountInBlock = 100;

	SendLogMessage(mmLog::debug,mmString(L"End Constructor"));
}
コード例 #26
0
ファイル: mmCalcMethod.cpp プロジェクト: ogx/Calculation2D
void mmImages::mmCalcMethod::SetCalculationMethodParameters(mmImages::mmImageStructureI* p_psImageStructure, mmImages::mmImagesCalculationMethodI::sCalculationAutomationParams* p_psAutomationParams)
{
	SendLogMessage(mmLog::debug,mmString(L"Start SetCalculationMethodParameters"));

	m_psImageStructure = p_psImageStructure;

	m_rProgress = 0.0;
	//m_iThreadsCount = 0;
	m_bFinishImage = false;

	// deserialize parameters
	DeserializeParameters(*p_psAutomationParams);
	
	// prepare map with first available row for each image
	m_mNextRows.clear();
	std::vector<mmID> v_sImageIDs = GetImageIDs();
	for (mmUInt i = 0; i < v_sImageIDs.size(); ++i) {
		m_mNextRows[v_sImageIDs[i]] = 0;
	}

	SendLogMessage(mmLog::debug,mmString(L"End SetCalculationMethodParameters"));
}
コード例 #27
0
ファイル: ApiLog.cpp プロジェクト: elazzi/winscp
void CApiLog::LogMessageRaw(int nMessageType, LPCTSTR pMsg) const
{
	ASSERT(nMessageType>=FZ_LOG_STATUS && nMessageType<=FZ_LOG_DEBUG);
	ASSERT(m_hTargetWnd || m_pApiLogParent);
	if (!LoggingMessageType(nMessageType))
		return;

#ifdef MPEXT
	if (nMessageType>=FZ_LOG_DEBUG)
		return;
#endif
	SendLogMessage(nMessageType, pMsg);
}
コード例 #28
0
mmSynchronize::mmReadWriteLockCSWindows::~mmReadWriteLockCSWindows()
{
	SendLogMessage(mmLog::debug,mmString(L"Start Destructor"));

	delete m_psExclusiveLock;

	if(m_iReadWriteCount != 0)
	{
		SendLogMessage(mmLog::critical,mmString(L"Destructor BadEndConditions RWCount=") +
																	 mmStringUtilities::MMIntToString(m_iReadWriteCount));

		throw mmError(mmeReadWriteLockBadEndLockCount);
	};
	if(m_bWaitForWriteLock)
	{
		SendLogMessage(mmLog::critical,mmString(L"Destructor BadEndConditions WaitForWrite=") +
																	 mmStringUtilities::BoolToString(m_bWaitForWriteLock));

		throw mmError(mmeReadWriteLockWaitForWrite);
	};

	SendLogMessage(mmLog::debug,mmString(L"End Destructor"));
}
コード例 #29
0
void mmThread::mmThreadWindows::RegisterThreadExecutionClass(mmThreadExecutionI* p_psThreadExecutionClass)
{
	SendLogMessage(mmLog::debug,mmString(L"Start RegisterThreadExecutionClass"));

	m_psExclusiveLock->Lock();
	try
	{
		if( (m_eThreadStatus == created) || (m_eThreadStatus == initialized) )
		{
			m_psThreadExecutionClass = p_psThreadExecutionClass;
			if(m_eThreadStatus != initialized)
			{
				m_eThreadStatus = initialized;
				SendLogMessage(mmLog::debug,mmString(L"RegisterThreadExecutionClass Status=initialized"));
			};

			SendLogMessage(mmLog::debug,mmString(L"RegisterThreadExecutionClass Registered PtrToExecutionObject=") +
																	mmStringUtilities::PointerToString(m_psThreadExecutionClass));
		}
		else
		{
			SendLogMessage(mmLog::critical,mmString(L"RegisterThreadExecutionClass CantRegister"));

			throw mmError(mmeThreadCantRegisterExecutionClass);
		};
	}
	catch(mmError &v_sErr)
  {
		m_psExclusiveLock->Unlock();

		throw v_sErr;
  };

	m_psExclusiveLock->Unlock();

	SendLogMessage(mmLog::debug,mmString(L"End RegisterThreadExecutionClass"));
}
コード例 #30
0
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////  mmSynchronize::mmReadWriteLockCSWindows
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
mmSynchronize::mmReadWriteLockCSWindows::mmReadWriteLockCSWindows(mmLog::mmLogReceiverI *p_psLogReceiver):
																																	mmLog::mmLogSender(L"mmSynchronize::mmReadWriteLockCSWindows",p_psLogReceiver)
{
	SendLogMessage(mmLog::debug,mmString(L"Start Constructor"));

	try
	{
		m_psExclusiveLock = mmInterfaceInitializers::CreateExclusiveLock(p_psLogReceiver);
	}
	catch(mmError &v_sErr)
	{
		if(v_sErr.GetErrorCode() == mmeBadAlloc)
		{
			SendLogMessage(mmLog::critical,mmString(L"Constructor ErrorAllocationMemory"));
		};

		throw;
	};

	m_iReadWriteCount = 0;
	m_bWaitForWriteLock = false;

	SendLogMessage(mmLog::debug,mmString(L"End Constructor PtrToExclusiveLock=") + mmStringUtilities::PointerToString(m_psExclusiveLock));
}