The in-proc session handler no longer removes and re-inserts an item in order to
update its timeout. It is now done using Cache.SetItemTimeout which, in turn, checks
whether the item being updated is already a timed one and, if yes, calls CacheItemPriorityQueue's
Update method for that item. Should the update fail or the item is not yet timed, the item is
enqueued to the priority queue in the regular fashion.
CacheItem got a new member, PriorityQueueIndex to mark its position in the queue's heap for faster
lookup and manipulation.
The CacheItemPriorityQueue.BubbleDown method was rewritten to properly swap items in the heap.
- Rewrote the CacheItem priority queue test generator to generate better code.
- CacheItem in System.Web doesn't have the unused Guid field now (the field is used only for tests)
- Added a huge sequence to CacheItem priority queue tests (10k entries)
This version uses an LRU cache to hold the cache items. Priority is not taken into account
when removing the underused entries (with the exception of the CacheItemPriority.NotRemovable
- items with this priority are never purged), they are treated equally.
A separate thread is not used to perform purging, instead the collection happens in the current
requests's thread.
Minor improvements to cache item enumerator and to the CheckDependencies method.
* Cache.cs: cache removes old/least recently used items when the item count exceeds 15000. Items
are removed until they reach the count of 10000.
* SessionInProcHandler.cs: replaced ReaderWriterLock with ReaderWriterLockSlim and added a Dispose
method to the InProcSessionItem type which disposes the associated lock and other resources.
The patch removes a small race condition where a boolean flag is set after acquiring a lock to
indicate to code executing in the finally {} block that it should release the lock. The boolean
variable is now removed and the lock is released unconditionally. It carries a potential to
throw an exception when the lock is not held, but it's better than to fail to release it and
lead the application to a deadlock.
* AssemblyInfo.cs: added back InternalsVisibleTo for the test
assembly - it's needed to access CacheItemPriorityQueue
2010-02-03 Marek Habersack <[email protected]>
* OutputCache.cs: DefaultProviderName checks if there was any
provider configured and, if not, returns a built-in provider's
name.
* SqlCacheDependencyAdmin.cs: added
* OutputCacheProviderCollection.cs: added
* OutputCacheProvider.cs: added
* OutputCacheModule.cs: uses the 4.0 extensible output cache
provider model now (also internally in the 2.0 profile)
OutputCacheProvider is retrieved on every request using
HttpApplication.GetOutputCacheProviderName (4.0+). In the 2.0
profile an instance of InMemoryOutputCacheProvider is always
returned.
* InMemoryOutputCacheProvider.cs: default output cache provider
for ASP.NET 4.0, also used internally in the 2.0 profile.
* CachedVaryBy.cs: made the generated key shorter
* CacheItemPriorityQueueDebug.cs: debugging support for
CacheItemPriorityQueue. Most of the code is compiled only when the
DEBUG macro is defined. Debugging support includes recording of
the queue operations sequence which is output to an XML file on
appdomain shutdown. The recorded sequence files can be used to
generate NUnit test cases for the priority queue (see
../Test/tools/README)
* CacheItemPriorityQueue.cs: rewritten using an array based heap
instead of a binary tree based one - implementation is simpler,
faster and more elegant. Heap is initially 32 entries long and
its size is doubled every time it fills up. After reaching a
threshold (8192 entries currently) it is shrunk to the number of
items + 1/3 of item count in order to preserve memory.
* CacheItem.cs: added a Guid field to easier distinguish items
(mostly for debugging purposes)
* CacheDependency.cs: minor performance improvements
* Cache.cs: better handling of timer periods
2010-02-03 Marek Habersack <[email protected]>
* HttpApplication.cs: GetOutputCacheProviderName returns the value
of OutputCache.DefaultProviderName
* HttpRuntime.cs: internal cache is used to hold the dependencies
now.
2010-02-03 Marek Habersack <[email protected]>
* CacheItemPriorityQueueTest_generated.cs: added
* CacheItemPriorityQueueTest.cs: added
2010-02-04 Marek Habersack <[email protected]>
* Helpers.cs: added a helper method for checking of HTML mentions
any .NET exceptions.
2010-02-03 Marek Habersack <[email protected]>
* Makefile: added targets to compile cache priority queue tests
generator and to generate the tests themselves
svn path=/trunk/mcs/; revision=150855
* Cache.cs: ExpireItems dequeues the next item when a disabled
item is found before continuing to look for items to expire. Fixes
bug #559470. Patch from Adriaan van Kekem <[email protected]>,
thanks.
svn path=/trunk/mcs/; revision=147213
* Cache.cs: if item expiration time exceeds the maximum value
Timer accepts, use the latter - item will expire properly anyway,
as the timer will be rescheduled for the item's expiration time
once that item is bubbled to the top of the priority queue. Fixes
bug #544171
svn path=/trunk/mcs/; revision=143384
* CacheItemPriorityQueue.cs, CacheItem.cs, CacheItemEnumerator.cs:
added
* Cache.cs: factored out CacheItem and CacheItemEnumerator to
separate files.
Use reader-writer locks instead of Monitor.
Added two 3.5sp1 properties - EffectivePrivateBytesLimit and
EffectivePercentagePhysicalMemoryLimit.
Added support for disabling cache item expiration.
One timer is used to expire all timed items (instead of one timer
per item). Timed items are kept in a priority queue.
svn path=/trunk/mcs/; revision=142664
* Cache.cs: System.Threading.Timer.Change takes a long, not an
int. The maximum value of sliding expiration is 365 days
(31536000000ms) which fits within the value range of long. The
previous cast to int might yield negative values in certain
situations which was the reason for bug #464221. Fixes bug #464221
svn path=/trunk/mcs/; revision=122839
* CapabilitiesChecksum.cs: implement Hex and MapToHex more efficiently.
2008-10-21 Marek Habersack <[email protected]>
* OutputCacheModule.cs: seal the class.
Made OnRawResponseRemoved a static method.
* CachedVaryBy.cs: seal the class.
Use portable line terminators instead of literal '\n'.
* Cache.cs: seal the CacheItem and CacheItemEnumerator classes.
* CacheDependency.cs: dispose the associated dependency in the
DependencyDispose method.
* CachedRawResponse.cs: seal the class
2008-10-21 Marek Habersack <[email protected]>
* CapabilitiesLoader.cs: seal BrowserData.
Seal CapabilitiesLoader.
Do not lock on typeof (CapabilitiesLoader) in GetCapabilities ().
svn path=/trunk/mcs/; revision=116583
Pass onRemoveCallback along in Insert. Fixes bugs #324528 and
#382644. Patch provided by Juraj Skripsky <[email protected]>,
thanks!
svn path=/trunk/mcs/; revision=110125
* Cache.cs: refactoring - move the timeout setting code to
separate methods, so that it can be accessed from outside the
class. Fixes bug #382644
2008-04-28 Marek Habersack <[email protected]>
* ISessionHandler.cs: added new method, Touch, to reset the item
timeout.
* SessionStateServerHandler.cs, SessionSQLServerHandler.cs,
SessionInProcHandler.cs: added implementation of the
ISessionHandler Touch method, to reset item timeout. Fixes bug
#382644
* StateServerItem.cs: made the Timeout property writable.
* SessionStateModule.cs: reset the item timeout after
OnSessionStart has returned. Fixes bug #382644
* RemoteStateServer.cs: added a method to reset item timeout.
svn path=/trunk/mcs/; revision=102034
* Cache.cs: MS allows calling Insert in a removed handler, we need to
avoid double locking here otherwise the Insert will never succeed.
svn path=/trunk/mcs/; revision=98559
* OutputCacheModule.cs: use Context.InternalCache.
* Cache.cs: 2.0 profile uses generic containers to keep the cache
entries.
Gotten rid of the InsertPrivate and InsertInternal methods. The
latter was moved to one of the Insert overloads.
Private entries are no longer handled specifically, because the
internal cache is now kept in a separate object.
2007-06-20 Marek Habersack <[email protected]>
* AppResourcesCompiler.cs: use HttpRuntime.InternalCache to keep
private entries.
* CachingCompiler.cs: as above
* AspGenerator.cs: as above
2007-06-20 Marek Habersack <[email protected]>
* DataSourceCacheManager.cs: use HttpContext.Current.InternalCache
to keep private entries.
* XmlDataSource.cs: as above
2007-06-20 Marek Habersack <[email protected]>
* SessionInProcHandler.cs: use HttpRuntime.InternalCache to keep
private entries.
2007-06-20 Marek Habersack <[email protected]>
* SessionInProcHandler.cs: use HttpRuntime.InternalCache to keep
the internal entries.
2007-06-20 Marek Habersack <[email protected]>
* BasePartialCachingControl.cs: use HttpRuntime.InternalCache to
keep the private entries.
2007-06-20 Marek Habersack <[email protected]>
* HttpRuntime.cs: added new internal property, InternalCache, to
keep all the internal cache entries instead of mixing them with
the public cache ones.
Do not invoke Cache.InvokePrivateCallbacks - this method no longer
exists.
* HttpResponse.cs: private entries are now kept in
Context.InternalCache.
* HttpContext.cs: added new internal property, InternalCache,
which returns the HttpRuntime.InternalCache value.
Fixes bug #81690
svn path=/trunk/mcs/; revision=80321
* System.Web.Caching/Cache.cs: new internal method.
* System.Web/HttpRuntime.cs: invoke callbacks on private items in the
cache before calling disposing the app. factory. This way we get
notifications of removal for all sessions stored in the cache (InProc
only). Fixes bug #76524.
svn path=/trunk/mcs/; revision=52113
* Cache.cs: Added security permissions with Minimal level for
AspNetHostingPermissionLevel (only LinkDemand as the class is sealed).
* CacheDependency.cs: : Added security permissions with Minimal level
for AspNetHostingPermissionLevel (note class is sealed only in 1.x).
svn path=/trunk/mcs/; revision=49342
* ExpiresBuckets.cs:
* Cache.cs:
* CacheExpires.cs: fix NullReferenceException thrown sometimes when
using sliding expiration and under high load. Patch by Eyal Alayuf from
Mainsoft.
svn path=/trunk/mcs/; revision=43705
* CacheEntry.cs,CacheExpires.cs,ExpiresBucket.cs,
Cache.cs : Fixed deadlock issues, fixed
items not correctly being flushed, fixed update
of item when expiration has been updated more
than 1 min (placed in wrong bucket),
fixed deadlock during cache callback when item
is removed due to expiriation.
Rewrite of locking handling in Cache class, leading
to better performance and less bugs.
This rewrite is due to a number of bugs found
in the output caching during load (leading to memory
leaks and deadlocks)
svn path=/trunk/mcs/; revision=28254
* CacheDependency.cs: Use FileSystemWatcher instead of custom
Watcher for file dependencies.
* OutputCacheModule.cs: Make the varyby objects dependent on the
cached page.
svn path=/trunk/mcs/; revision=22924
removed yet.
* OutputCacheModule.cs: Handle sliding expirations. Remove hacks
checking if the item is expired, the cache no longer returns
expired items.
svn path=/trunk/mcs/; revision=22103
expires time as well as the expires entry expire time because the
objects expire time is checked when objects are pulled out. This
fixex bug #52778.
svn path=/trunk/mcs/; revision=22100
* CachedRawResponse.cs: New file - A snapshot of a response that
is stored in the cache and can be used to create a new response.
* OutputCacheModule.cs: Module for inserting and retrieving
responses from the cache.
svn path=/trunk/mcs/; revision=20272
* System.Web/HttpRuntime.cs: Cache no longer have a Dispose method.
* System.Web/HttpServerUtility.cs: removed MonoTODO.
* System.Web.Caching/Cache.cs:
* System.Web.Caching/CacheDefinitions.cs:
* System.Web.Caching/CacheDependency.cs:
* System.Web.Caching/CacheEntry.cs:
* System.Web.Caching/CacheExpires.cs:
* System.Web.Caching/ExpiresBuckets.cs: reformatted, make class status
page happier. Does not work yet (wait for the next patch).
* System.Web.SessionState/HttpSessionState.cs: implemented CodePage.
* System.Web.SessionState/SessionStateModule.cs: initial stuff to make
it work.
svn path=/trunk/mcs/; revision=12480
2002-12-27 Daniel Cazzulino <[email protected]>
* CacheEntry.cs: several changes. New constants, use of constants
defined in Cache.cs, modified locks to optimize perf. Fixed property
sets which weren't using the keyword value to set the new values
(don't know how this worked before!).
* Cache.cs: changed singleton implementation to only create the object
when actually used. Changed Insert overloads to use constants
defined instead of hard values.
* ExpiresBuchets: major changes. All locking now uses ReaderWriterLock
class. Bucket now efectively reuses free indexes from removed items
to avoid unnecessary expansions. Expansion now uses Array.CopyTo to
add elements to the new list. Added private Int32Collection to
handle int indexes efficiently (thanks Shawn Van Ness). See comments
there.
svn path=/trunk/mcs/; revision=9985