1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/lowlevellibsandfws/pluginfw/Framework/frame/resolvercache.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,371 @@
1.4 +// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +/**
1.20 + @file
1.21 + @internalComponent
1.22 +*/
1.23 +
1.24 +#include <e32def.h>
1.25 +#include <e32cmn.h>
1.26 +#include <hal.h>
1.27 +#include "EComDebug.h"
1.28 +#include "ImplementationInformation.h" // CompareTUidValues
1.29 +#include "callback.h"
1.30 +#include "resolvercache.h"
1.31 +#include "EComPatchDataConstantv2.h"
1.32 +
1.33 +const TInt KCacheQueueGranularity = 4;
1.34 +
1.35 +//
1.36 +// TCounterTicks class
1.37 +//
1.38 +inline TCounterTicks::TCounterTicks(TUint aTicks)
1.39 + : iTicks(aTicks)
1.40 + {
1.41 + }
1.42 +
1.43 +/** This substraction calculate elapsed ticks: aEndTick - this */
1.44 +inline
1.45 +TUint TCounterTicks::ElapsedSinceThis(TUint aEndTick) const
1.46 + {
1.47 + TUint diff;
1.48 + if (aEndTick < iTicks) // wrap around occurred
1.49 + {
1.50 + diff = KMaxTUint - iTicks + aEndTick + 1;
1.51 + }
1.52 + else
1.53 + {
1.54 + diff = aEndTick - iTicks;
1.55 + }
1.56 + return diff;
1.57 + }
1.58 +
1.59 +/** default constructor which initializes all member data to 0. */
1.60 +RResolverCacheEntry::RResolverCacheEntry()
1.61 + : iLastUse( TCounterTicks(0) ), iLruRank(0), iResolverUid(KNullUid),
1.62 + iNewLFuncPtr(NULL), iFlags(EEntryFlagsNone)
1.63 + {
1.64 + iLibrary.SetHandle(KNullHandle);
1.65 + }
1.66 +
1.67 +/** construct RResolverCacheEntry with specific data
1.68 +@param aResolverUid TUid of the resolver.
1.69 +@param aLib RLibrary with handle open on the resolver DLL.
1.70 +@param aNewL Function ptr to instantiate the resolver.
1.71 +@param aFlags Special conditions about the cache entry.
1.72 +*/
1.73 +RResolverCacheEntry::RResolverCacheEntry(const TUid aResolverUid,
1.74 + RLibrary aLib,
1.75 + TProxyNewLPtr aNewL,
1.76 + TUint32 aFlags)
1.77 + : iLastUse( TCounterTicks(0) ), iLruRank(0), iResolverUid(aResolverUid),
1.78 + iNewLFuncPtr(aNewL), iFlags(aFlags)
1.79 + {
1.80 + iLibrary.SetHandle(aLib.Handle());
1.81 + }
1.82 +
1.83 +/** unallocate resources owned by the RResolverCacheEntry object */
1.84 +void RResolverCacheEntry::Close()
1.85 + {
1.86 + iLibrary.Close();
1.87 + }
1.88 +
1.89 +/** This method compares two RResolverCacheEntry objects.
1.90 +@param aEntry1 first RResolverCacheEntry object.
1.91 +@param aEntry2 second RResolverCacheEntry object.
1.92 +@return 0 means the two objects are equal.
1.93 + positive value means first object is greater than the second.
1.94 + negative vlaue means second object is greater than the first.
1.95 +*/
1.96 +TInt RResolverCacheEntry::CompareUid(const RResolverCacheEntry& aEntry1,
1.97 + const RResolverCacheEntry& aEntry2)
1.98 + {
1.99 + return CompareTUidValues(aEntry1.iResolverUid.iUid,
1.100 + aEntry2.iResolverUid.iUid);
1.101 + }
1.102 +
1.103 +/** Compare the age of two cache entries.
1.104 +@param aOther The RResolverCacheEntry to compare with.
1.105 +@param aCurrTick The current system tick. It simplifies handling
1.106 + of system tick wrap around to zero.
1.107 +@return ETrue means "this" object is older than aOther.
1.108 + EFalse means aOther is older than "this".
1.109 +*/
1.110 +TBool RResolverCacheEntry::ThisIsOlder(const RResolverCacheEntry& aOther,
1.111 + TUint aCurrTick) const
1.112 + {
1.113 + if (iLastUse.iTicks == aOther.iLastUse.iTicks)
1.114 + {
1.115 + return iLruRank < aOther.iLruRank;
1.116 + }
1.117 +
1.118 + // Because of counter wrap around, it is not safe to directly
1.119 + // compare the two ticks. Drag in the current system tick.
1.120 + return iLastUse.ElapsedSinceThis(aCurrTick) >
1.121 + aOther.iLastUse.ElapsedSinceThis(aCurrTick);
1.122 + }
1.123 +
1.124 +//=================================
1.125 +// CCustomResolverCache class
1.126 +//=================================
1.127 +
1.128 +/** CCustomResolverCache constructor
1.129 +@param aCacheSize Maximum number of entries allowed to cache.
1.130 +*/
1.131 +CCustomResolverCache::CCustomResolverCache(TUint32 aCacheSize)
1.132 + : CTimer(CActive::EPriorityStandard),
1.133 + iResolvers(KCacheQueueGranularity),
1.134 + iMaxCacheSize(aCacheSize)
1.135 + {
1.136 + }
1.137 +
1.138 +/** static factory method to instantiate CCustomResolverCache
1.139 +@param aCacheSize Maximum number of entries allowed to cache.
1.140 +@param aCacheTimeout Cache timeout in microseconds.
1.141 +@leave Any of the system wide error codes.
1.142 +*/
1.143 +CCustomResolverCache* CCustomResolverCache::NewL(TUint32 aCacheSize, TUint32 aCacheTimeout)
1.144 + {
1.145 + CCustomResolverCache* self = new (ELeave) CCustomResolverCache(aCacheSize);
1.146 + CleanupStack::PushL(self);
1.147 + self->ConstructL(aCacheTimeout);
1.148 + CleanupStack::Pop(self);
1.149 + return self;
1.150 + }
1.151 +
1.152 +/** Standard two phase construction to complete construction of
1.153 +the CCustomResolverCache object.
1.154 +@param aCacheTimeout Cache timeout in microseconds.
1.155 +@leave Any of the system wide error codes.
1.156 +*/
1.157 +void CCustomResolverCache::ConstructL(TUint32 aCacheTimeout)
1.158 + {
1.159 + User::LeaveIfError(HAL::Get(HALData::ESystemTickPeriod,
1.160 + iSystemTickPeriod));
1.161 + iEntryTimeToLive = (aCacheTimeout + iSystemTickPeriod - 1) / iSystemTickPeriod;
1.162 +
1.163 + CTimer::ConstructL();
1.164 + CActiveScheduler::Add(this);
1.165 + }
1.166 +
1.167 +/** CCustomResolverCache destructor */
1.168 +CCustomResolverCache::~CCustomResolverCache()
1.169 + {
1.170 + Cancel();
1.171 + for (TInt i = iResolvers.Count() - 1; i >= 0; i--)
1.172 + {
1.173 + iResolvers[i].Close();
1.174 + }
1.175 + iResolvers.Reset();
1.176 + }
1.177 +
1.178 +/** Implement the CActive RunL pure virtual */
1.179 +void CCustomResolverCache::RunL()
1.180 + {
1.181 + TUint currTickCount = User::TickCount();
1.182 + TUint lruAge = 0;
1.183 +
1.184 + for (TInt i = iResolvers.Count() - 1; i >= 0; i--)
1.185 + {
1.186 + RResolverCacheEntry& resolverEntry = iResolvers[i];
1.187 + TUint age = resolverEntry.iLastUse.ElapsedSinceThis(currTickCount);
1.188 + if (age >= iEntryTimeToLive)
1.189 + {
1.190 + resolverEntry.Close();
1.191 + iResolvers.Remove(i);
1.192 + }
1.193 + else if (age > lruAge)
1.194 + {
1.195 + lruAge = age;
1.196 + }
1.197 + }
1.198 +
1.199 + if (iResolvers.Count() > 0)
1.200 + {
1.201 + After( iSystemTickPeriod * (iEntryTimeToLive - lruAge + 1) );
1.202 + }
1.203 +
1.204 +#ifdef __ECOMSERVER_TESTING__
1.205 + // In unit testing notify test bed that cache timer has fired.
1.206 + iTimerExpireCB.CallBack(0, NULL);
1.207 +#endif
1.208 + }
1.209 +
1.210 +/** Search of a resolver UID in cache
1.211 +@param aResolverUid the resolver to search for.
1.212 +@return If find is successful, index of the resolver in RArray of cached resolvers.
1.213 + Return KErrNotFound if resolver is not in cache.
1.214 +*/
1.215 +TInt CCustomResolverCache::FindResolver(const TUid aResolverUid) const
1.216 + {
1.217 + RResolverCacheEntry trgt;
1.218 + trgt.iResolverUid = aResolverUid;
1.219 + TLinearOrder<RResolverCacheEntry> comparator(RResolverCacheEntry::CompareUid);
1.220 + return iResolvers.FindInOrder(trgt, comparator);
1.221 + }
1.222 +
1.223 +/** Add a resolver library to cache
1.224 +@param aResolverUid Implementation UID of the resolver.
1.225 +@param aLib The RLibrary object which has the resolver loaded. The handle
1.226 + of the RLibrary is owned by the cache if call is successful.
1.227 +@param aNewL value for the iNewLFuncPtr member data of RResolverCacheEntry.
1.228 +@param aFlags value for the iFlags member data of RResolverCacheEntry.
1.229 +@return KErrNone if the data is added to cache.
1.230 + KErrNoMemory if fail to insert the data in RArray.
1.231 +*/
1.232 +TInt CCustomResolverCache::CacheResolver(const TUid aResolverUid,
1.233 + RLibrary aLib,
1.234 + TProxyNewLPtr aNewL,
1.235 + TUint32 aFlags)
1.236 + {
1.237 + if (iResolvers.Count() == iMaxCacheSize)
1.238 + {
1.239 + EvictLeastRecentlyUsed();
1.240 + }
1.241 +
1.242 + RResolverCacheEntry entry(aResolverUid, aLib, aNewL, aFlags);
1.243 + SetLastUseTime(entry);
1.244 +
1.245 +#ifdef ECOM_TRACE
1.246 + __ECOM_TRACE2("ECOM: adding custom resolver 0x%X to cache. New queue size will be %d.\n", aResolverUid.iUid, 1 + iResolvers.Count());
1.247 +#endif
1.248 +
1.249 + TLinearOrder<RResolverCacheEntry> comparator(RResolverCacheEntry::CompareUid);
1.250 + TInt err = iResolvers.InsertInOrder(entry, comparator);
1.251 +
1.252 + // if cache was empty before need to start timer
1.253 + if (err == KErrNone && ! IsActive())
1.254 + {
1.255 + After( iSystemTickPeriod * (iEntryTimeToLive + 1) );
1.256 + }
1.257 + return err;
1.258 + }
1.259 +
1.260 +/** Check if both queue size and cache timeout are non zero */
1.261 +TBool CCustomResolverCache::CachingEnabled() const
1.262 + {
1.263 + return (iMaxCacheSize && iEntryTimeToLive);
1.264 + }
1.265 +
1.266 +/** Remove a cached entry
1.267 +@param aIndex position of entry in the array.
1.268 +*/
1.269 +void CCustomResolverCache::Remove(TInt aIndex)
1.270 + {
1.271 + iResolvers[aIndex].Close();
1.272 + iResolvers.Remove(aIndex);
1.273 + }
1.274 +
1.275 +/** Search for a resolverUID. If found, return the NewL pointer and
1.276 +update time to live of the entry.
1.277 +@param aResolverUid the resolver to lookup
1.278 +@param aNewLFuncPtr output parameter. If lookup successful it has
1.279 + the function pointer to instantiate the resolver.
1.280 +@return True if resolver is in cache. False otherwise.
1.281 +@post If cache hit, the timestamp of the entry is updated.
1.282 +*/
1.283 +TBool CCustomResolverCache::CacheLookup(const TUid aResolverUid,
1.284 + TProxyNewLPtr& aNewLFuncPtr)
1.285 + {
1.286 + TInt i = FindResolver(aResolverUid);
1.287 + if (i >= 0)
1.288 + {
1.289 + aNewLFuncPtr = iResolvers[i].iNewLFuncPtr;
1.290 + SetLastUseTime(iResolvers[i]);
1.291 + }
1.292 + return (i >= 0);
1.293 + }
1.294 +
1.295 +/** Remove a resolver from cache.
1.296 +@param aResolverUid Identify the resolver to remove.
1.297 +@return ETrue if aResolverUid is found in cache. EFalse means the
1.298 + resolver is not in cache.
1.299 +*/
1.300 +TBool CCustomResolverCache::Remove(const TUid aResolverUid)
1.301 + {
1.302 + TInt i = FindResolver(aResolverUid);
1.303 + if (i >= 0)
1.304 + {
1.305 + Remove(i);
1.306 + }
1.307 + return (i >= 0);
1.308 + }
1.309 +
1.310 +/** Remove cached entries with flags set.
1.311 +@param aMask If an entry has any of the bits in aMask set, it is removed.
1.312 +*/
1.313 +void CCustomResolverCache::RemoveItemsWithFlags(TUint32 aMask)
1.314 + {
1.315 + for (TInt i = iResolvers.Count() - 1; i >= 0; i--)
1.316 + {
1.317 + if (iResolvers[i].iFlags & aMask)
1.318 + {
1.319 + Remove(i);
1.320 + }
1.321 + }
1.322 + }
1.323 +
1.324 +/** evict the least recently used entry in cache
1.325 +*/
1.326 +void CCustomResolverCache::EvictLeastRecentlyUsed()
1.327 + {
1.328 + TUint curr = User::TickCount();
1.329 + TInt index = 0; // set to first entry in cache.
1.330 +
1.331 + for (TInt i = 1; i < iResolvers.Count(); i++)
1.332 + {
1.333 + RResolverCacheEntry& resolverEntry = iResolvers[i];
1.334 + if (resolverEntry.ThisIsOlder(iResolvers[index], curr))
1.335 + {
1.336 + index = i;
1.337 + }
1.338 + }
1.339 +
1.340 + Remove(index);
1.341 + }
1.342 +
1.343 +/** Set the iLastUse field and iLruRank field of the entry.
1.344 +The iLruRank field serves as tie breaker when two entries are
1.345 +added within the same tick period.
1.346 +@param aEntry The entry to update.
1.347 +*/
1.348 +void CCustomResolverCache::SetLastUseTime(RResolverCacheEntry& aEntry)
1.349 + {
1.350 + TUint curr = User::TickCount();
1.351 + aEntry.iLastUse.iTicks = curr;
1.352 + aEntry.iLruRank = 0;
1.353 +
1.354 + if (curr == iMostRecentTimestamp)
1.355 + {
1.356 + // There are entries with same timestamp. So have to step
1.357 + // through each cache entry to resolve senority.
1.358 + for (TInt i = 0; i < iResolvers.Count(); i++)
1.359 + {
1.360 + RResolverCacheEntry& another = iResolvers[i];
1.361 + if (another.iLastUse.iTicks == curr &&
1.362 + another.iResolverUid != aEntry.iResolverUid &&
1.363 + another.iLruRank >= aEntry.iLruRank)
1.364 + {
1.365 + aEntry.iLruRank = another.iLruRank + 1;
1.366 + }
1.367 + }
1.368 + }
1.369 + else
1.370 + {
1.371 + iMostRecentTimestamp = curr;
1.372 + }
1.373 + }
1.374 +