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

equal deleted inserted replaced

-:a365cb779476
+:cf589eb1e31e
 class CTransportSelfSender : public CActive, public MBindingAwareTransportSender
 	{
 public:
 	enum
 		{
-		KSelfSenderInitialQueueLength = 40,	/** Initial size of self-sender queue (double what testing has observed) */
+		KSelfSenderInitialQueueLength = 20, /** Initial size of self-sender queue */
-		KSelfSenderQueueGrowthStep = 40,	/** Increment of self-sender queue size when full. PostMessage() functions panic if growth
+		KSelfSenderQueuePreAllocationGrowthStep = 20, /** Additionl space to reserve each time we pre-allocate some queue space to avoind too much re-allocation */
-											    required and fails; to minimise this risk ensure initial size adequate for all likely cases */
+		KSelfSenderQueueGrowthStep = 20 /** Increment of self-sender queue size when full. PostMessage() functions panic if growth required and fails */
 		};
 	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();
-	TInt ResizeQueue(TInt aAdditionalChips);
+	void ResizeQueueL(TInt aAdditionalChips);
 private:
 	TChipReceiver iReceiver;
 	CCirBuf<TCFMessage>* iBuf;
 	};
 	self->ConstructL();
 	CActiveScheduler::Add(self);
 	CleanupStack::Pop(self);
 	return self;
 	}
+/*
-TInt CTransportSelfSender::ResizeQueue(TInt aAdditionalChips)
+* Preemptively allocate self sender queue length, given by aMinUndeliveredMessages.
-	{
+* 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 CCirBuf<TCFMessage>;
+	CCirBuf<TCFMessage>* newBuf = new (ELeave) CCirBuf<TCFMessage>;
-	if(newBuf == NULL)
+	CleanupStack::PushL(newBuf);
-		{
+	newBuf->SetLengthL(newLen);
-		__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 ));
+	CleanupStack::Pop(newBuf);
-		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)
 		{
-		ResizeQueue(KSelfSenderQueueGrowthStep);
+		TRAP_IGNORE(ResizeQueueL(KSelfSenderQueueGrowthStep));
 		ret = DoPostMessage(aMessage);
-		//For the benefit of OOM testing as we currently do it (only the sequential failure model)
+		}
-		//we attempt to resize the queue for the second time.
+	__ASSERT_ALWAYS(ret == KErrNone, Panic(ECFTransPeerDrainFailure));	// true, even though peer is us...
-		//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)
 		{
-		ResizeQueue(KSelfSenderQueueGrowthStep);
+		TRAP_IGNORE(ResizeQueueL(KSelfSenderQueueGrowthStep));
 		ret = DoPostMessage(aPostFrom, aPostTo, aMessage);
-		//For the benefit of OOM testing as we currently do it (only the sequential failure model)
+		}
-		//we attempt to resize the queue for the second time.
+	__ASSERT_ALWAYS(ret == KErrNone, Panic(ECFTransPeerDrainFailure));	// true, even though peer is us...
-		//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
 				{
-				ResizeQueue(KSelfSenderQueueGrowthStep);
+				TRAP_IGNORE(ResizeQueueL(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)
 	{

changeset 79	cf589eb1e31e
parent 25	e53adc4c49de
child 84	486e9e9c45a7