FCL/sf/os/commsfw: comparison commsfwsupport/commselements/commsfw/src/cftransport.cpp

equal deleted inserted replaced

-:576874e13a2c
+:486e9e9c45a7
 class CTransportSelfSender : public CActive, public MBindingAwareTransportSender
 	{
 public:
 	enum
 		{
-		KSelfSenderInitialQueueLength = 20, /** Initial size of self-sender queue */
+		KSelfSenderInitialQueueLength = 120,	/** H a c k alert. Initial size of self-sender queue. This is based on testing involving closing 40 sockets by just closing the session */
-		KSelfSenderQueuePreAllocationGrowthStep = 20, /** Additionl space to reserve each time we pre-allocate some queue space to avoind too much re-allocation */
+		KSelfSenderQueueGrowthStep = 40,		/** Increment of self-sender queue size when full. PostMessage() functions panic if growth
-		KSelfSenderQueueGrowthStep = 20 /** Increment of self-sender queue size when full. PostMessage() functions panic if growth required and fails */
+											    required and fails; to minimise this risk ensure initial size adequate for all likely cases */
 		};
 	static CTransportSelfSender* NewL(MMessageDispatcher& aDispatcher, TWorkerId aSelfId);
 private:
 		}
 	virtual TBool IsDropTransportPending() const
 		{
 		return EFalse;
 		}
-	void PreallocateQueueSpaceL(TInt aMinUndeliveredMessages);
 	~CTransportSelfSender();
 protected:
 	void RunL();
 	TInt RunError(TInt aError);
 	void ConstructL();
 	TInt DoPostMessage(const TCFMessage& aMessage);
 	TInt DoPostMessage(const TRuntimeCtxId& aPostFrom, const TRuntimeCtxId& aPostTo, const TDesC8& aMessage);
 	TInt ProcessMessage(TCFMessage2& aMessage, TInt aFirstDispatchLeaveReason);
 	void MaybeTriggerReceipt();
-	void ResizeQueueL(TInt aAdditionalChips);
+	TInt ResizeQueue(TInt aAdditionalChips);
 private:
 	TChipReceiver iReceiver;
 	CCirBuf<TCFMessage>* iBuf;
 	};
 	self->ConstructL();
 	CActiveScheduler::Add(self);
 	CleanupStack::Pop(self);
 	return self;
 	}
-/*
-* Preemptively allocate self sender queue length, given by aMinUndeliveredMessages.
+TInt CTransportSelfSender::ResizeQueue(TInt aAdditionalChips)
-* Note the current logic for queue enlargement is rather coarse, preferring linear growth by a fixed amount.
+	{
-* A better approach would have been to implement a logarithmic increase for the queue length, which would have saved a bit more memory when the
-*/
-void CTransportSelfSender::PreallocateQueueSpaceL(TInt aMinUndeliveredMessages)
-	{
-	TInt currentLength = iBuf->Length();
-	if (aMinUndeliveredMessages > currentLength)
-		{
-		TInt resizeBy = aMinUndeliveredMessages - currentLength;
-		__CFLOG_VAR(( KLogCommsFw, KLogFwTransport, _L8("CTransportSelfSender::PreallocateQueueSpaceL(%d) Trying to enlarge queue from %d to %d chips"), aMinUndeliveredMessages, currentLength, currentLength + resizeBy + KSelfSenderQueuePreAllocationGrowthStep ));
-		ResizeQueueL(resizeBy + KSelfSenderQueuePreAllocationGrowthStep);
-		__CFLOG_VAR(( KLogCommsFw, KLogFwTransport, _L8("CTransportSelfSender::PreallocateQueueSpaceL queue enlargement successful") ));
-		}
-	}
-void CTransportSelfSender::ResizeQueueL(TInt aAdditionalChips)
-	{
-	__CFLOG_VAR(( KLogCommsFw, KLogFwTransport, _L8("CTransportSelfSender::ResizeQueueL(%d)"), aAdditionalChips ));
 	TInt newLen = iBuf->Length() + aAdditionalChips;
 	__ASSERT_ALWAYS(newLen > iBuf->Count(), Panic(ECFInvalidQueueSize));
-	if (iBuf->Count() == 0)
-		{
-		iBuf->SetLengthL(newLen);
-		return;
-		}
 	// Create a new queue of the requisite size, copy the elements, and swap for the original
 	// (there's no safe way to resize in-place).
-	CCirBuf<TCFMessage>* newBuf = new (ELeave) CCirBuf<TCFMessage>;
+	CCirBuf<TCFMessage>* newBuf = new CCirBuf<TCFMessage>;
-	CleanupStack::PushL(newBuf);
+	if(newBuf == NULL)
-	newBuf->SetLengthL(newLen);
+		{
-	CleanupStack::Pop(newBuf);
+		__CFLOG_VAR(( KLogCommsFw, KLogFwTransport, _L8("ERROR: CTransportSelfSender::ResizeQueue() unable to enlarge queue from %d chips to %d chips because error -4 occured"), iBuf->Length(), newLen ));
+		return KErrNoMemory;
+		}
+	TRAPD(ret, newBuf->SetLengthL(newLen));
+	if(ret != KErrNone)
+		{
+		__CFLOG_VAR(( KLogCommsFw, KLogFwTransport, _L8("ERROR: CTransportSelfSender::ResizeQueue() unable to enlarge queue from %d chips to %d chips because error %d occured"), iBuf->Length(), newLen, ret ));
+		return ret;
+		}
 	TCFMessage entry;
 	while(iBuf->Remove(&entry))
 		{
 		VERIFY( newBuf->Add(&entry) );
 		}
 	delete iBuf;
 	iBuf = newBuf;
+	return KErrNone;
 	}
 void CTransportSelfSender::PostMessage(const TCFMessage& aMessage)
 	{
 	TInt ret = DoPostMessage(aMessage);
 	if(ret != KErrNone)
 		{
-		TRAP_IGNORE(ResizeQueueL(KSelfSenderQueueGrowthStep));
+		ResizeQueue(KSelfSenderQueueGrowthStep);
 		ret = DoPostMessage(aMessage);
-		}
+		//For the benefit of OOM testing as we currently do it (only the sequential failure model)
-	__ASSERT_ALWAYS(ret == KErrNone, Panic(ECFTransPeerDrainFailure));	// true, even though peer is us...
+		//we attempt to resize the queue for the second time.
+		//In real scenarios this approach has very limited or no value as the OOM conditions do rarely
+		//resemble the ones of our sequential failure OOM testing.
+		//Therefore it would probably make sense to configure out the code for UREL and only keep
+		//it for _DEBUG.
+		if(ret != KErrNone)
+			{
+			ResizeQueue(KSelfSenderQueueGrowthStep);
+			ret = DoPostMessage(aMessage);
+			__ASSERT_ALWAYS(ret == KErrNone, Panic(ECFTransPeerDrainFailure));	// true, even though peer is us...
+			}
+		}
 	}
 void CTransportSelfSender::PostMessage(const TRuntimeCtxId& aPostFrom, const TRuntimeCtxId& aPostTo, const TDesC8& aMessage)
 	{
 	__ASSERT_ALWAYS(aPostFrom.Size() + aPostTo.Size() + aMessage.Length() <= CommsFW::KMaxInlineMessageSize, User::Panic(KCFChannelPanic, ECFChanMsgTooBig));
 	TInt ret = DoPostMessage(aPostFrom, aPostTo, aMessage);
 	if(ret != KErrNone)
 		{
-		TRAP_IGNORE(ResizeQueueL(KSelfSenderQueueGrowthStep));
+		ResizeQueue(KSelfSenderQueueGrowthStep);
 		ret = DoPostMessage(aPostFrom, aPostTo, aMessage);
-		}
+		//For the benefit of OOM testing as we currently do it (only the sequential failure model)
-	__ASSERT_ALWAYS(ret == KErrNone, Panic(ECFTransPeerDrainFailure));	// true, even though peer is us...
+		//we attempt to resize the queue for the second time.
+		//In real scenarios this approach has very limited or no value as the OOM conditions do rarely
+		//resemble the ones of our sequential failure OOM testing.
+		//Therefore it would probably make sense to configure out the code for UREL and only keep
+		//it for _DEBUG.
+		if(ret != KErrNone)
+			{
+			ResizeQueue(KSelfSenderQueueGrowthStep);
+			ret = DoPostMessage(aPostFrom, aPostTo, aMessage);
+			__ASSERT_ALWAYS(ret == KErrNone, Panic(ECFTransPeerDrainFailure));	// true, even though peer is us...
+			}
+		}
 	}
 #ifdef SYMBIAN_CFTRANSPORT_SUPPORT_IMPATIENCE
 /** Needs more testing before deployment
 				// First chip, safe to error
 				return KErrOverflow;
 				}
 			else
 				{
-				TRAP_IGNORE(ResizeQueueL(KSelfSenderQueueGrowthStep));
+				ResizeQueue(KSelfSenderQueueGrowthStep);
 				err = DoPostMessage(*msgPtr);
 				if(err != KErrNone)
 					{
 					Panic(ECFTransPeerDrainFailure);	// true, even though peer is us... should try growing ring buf
 					}
 	TBool IsDropTransportPending(TWorkerId aPeerId) const
 		{
 		return GetSenderMandatory(aPeerId)->IsDropTransportPending();
 		}
-	void PreallocateQueueSpaceL(TInt aMinUndeliveredMessages);
 	void RunL();	// for deleting chippers posted to death row
 private:
 	CCommsTransportImpl(MWorkerThreadRegister& aThreadRegister, const CMetaDataVirtualCtorInPlace* aVirtCtor)
 		: CAsyncOneShot(EPriorityLow),
 		iChipperDeathRow.Remove(*chipper);
 		delete chipper;
 		}
 	}
-void CCommsTransportImpl::PreallocateQueueSpaceL(TInt aMinUndeliveredMessages)
-	{
-#ifndef SYMBIAN_NETWORKING_INTERTHREAD_TRANSPORT_ONLY
-	iSelfSender->PreallocateQueueSpaceL(aMinUndeliveredMessages);
-#else
-	(void)aSize; // Do nothing
-#endif
-	}
 //
 EXPORT_C CCommsTransport* CCommsTransport::NewL(MWorkerThreadRegister& aThreadRegister, const CMetaDataVirtualCtorInPlace* aVirtCtor, CCFTransportHooks* /*aHooksWalker*/)
 	{
 	CCommsTransport* self = new(ELeave) CCommsTransport;
 EXPORT_C TBool CCommsTransport::IsDropTransportPending(TWorkerId aPeerId) const
 	{
 	return iImpl->IsDropTransportPending(aPeerId);
 	}
-EXPORT_C void CCommsTransport::PreallocateQueueSpaceL(TInt aMinUndeliveredMessages)
-	{
-	iImpl->PreallocateQueueSpaceL(aMinUndeliveredMessages);
-	}
 //
 TCFMessage2::TCFMessage2(const TRuntimeCtxId& aPostFrom, const TRuntimeCtxId& aPostTo, const TDesC8& aData)
 	{

branch	RCL_3
changeset 84	486e9e9c45a7
parent 76	576874e13a2c