CenomeAssetCache.cs 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401
  1. /*
  2. * Copyright (c) Contributors, http://opensimulator.org/
  3. * See CONTRIBUTORS.TXT for a full list of copyright holders.
  4. *
  5. * Redistribution and use in source and binary forms, with or without
  6. * modification, are permitted provided that the following conditions are met:
  7. * * Redistributions of source code must retain the above copyright
  8. * notice, this list of conditions and the following disclaimer.
  9. * * Redistributions in binary form must reproduce the above copyright
  10. * notice, this list of conditions and the following disclaimer in the
  11. * documentation and/or other materials provided with the distribution.
  12. * * Neither the name of the OpenSimulator Project nor the
  13. * names of its contributors may be used to endorse or promote products
  14. * derived from this software without specific prior written permission.
  15. *
  16. * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
  17. * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18. * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19. * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
  20. * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  21. * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  22. * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  23. * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24. * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  25. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26. */
  27. using System;
  28. using System.Reflection;
  29. using log4net;
  30. using Nini.Config;
  31. using OpenSim.Framework;
  32. using OpenSim.Region.Framework.Interfaces;
  33. using OpenSim.Region.Framework.Scenes;
  34. namespace OpenSim.Region.CoreModules.Asset
  35. {
  36. /// <summary>
  37. /// Cenome memory asset cache.
  38. /// </summary>
  39. /// <remarks>
  40. /// <para>
  41. /// Cache is enabled by setting "AssetCaching" configuration to value "CenomeMemoryAssetCache".
  42. /// When cache is successfully enable log should have message
  43. /// "[ASSET CACHE]: Cenome asset cache enabled (MaxSize = XXX bytes, MaxCount = XXX, ExpirationTime = XXX)".
  44. /// </para>
  45. /// <para>
  46. /// Cache's size is limited by two parameters:
  47. /// maximal allowed size in bytes and maximal allowed asset count. When new asset
  48. /// is added to cache that have achieved either size or count limitation, cache
  49. /// will automatically remove less recently used assets from cache. Additionally
  50. /// asset's lifetime is controlled by expiration time.
  51. /// </para>
  52. /// <para>
  53. /// <list type="table">
  54. /// <listheader>
  55. /// <term>Configuration</term>
  56. /// <description>Description</description>
  57. /// </listheader>
  58. /// <item>
  59. /// <term>MaxSize</term>
  60. /// <description>Maximal size of the cache in bytes. Default value: 128MB (134 217 728 bytes).</description>
  61. /// </item>
  62. /// <item>
  63. /// <term>MaxCount</term>
  64. /// <description>Maximal count of assets stored to cache. Default value: 4096 assets.</description>
  65. /// </item>
  66. /// <item>
  67. /// <term>ExpirationTime</term>
  68. /// <description>Asset's expiration time in minutes. Default value: 30 minutes.</description>
  69. /// </item>
  70. /// </list>
  71. /// </para>
  72. /// </remarks>
  73. /// <example>
  74. /// Enabling Cenome Asset Cache:
  75. /// <code>
  76. /// [Modules]
  77. /// AssetCaching = "CenomeMemoryAssetCache"
  78. /// </code>
  79. /// Setting size and expiration time limitations:
  80. /// <code>
  81. /// [AssetCache]
  82. /// ; 256 MB (default: 134217728)
  83. /// MaxSize = 268435456
  84. /// ; How many assets it is possible to store cache (default: 4096)
  85. /// MaxCount = 16384
  86. /// ; Expiration time - 1 hour (default: 30 minutes)
  87. /// ExpirationTime = 60
  88. /// </code>
  89. /// </example>
  90. public class CenomeMemoryAssetCache : IImprovedAssetCache, ISharedRegionModule
  91. {
  92. /// <summary>
  93. /// Cache's default maximal asset count.
  94. /// </summary>
  95. /// <remarks>
  96. /// <para>
  97. /// Assuming that average asset size is about 32768 bytes.
  98. /// </para>
  99. /// </remarks>
  100. public const int DefaultMaxCount = 4096;
  101. /// <summary>
  102. /// Default maximal size of the cache in bytes
  103. /// </summary>
  104. /// <remarks>
  105. /// <para>
  106. /// 128MB = 128 * 1024^2 = 134 217 728 bytes.
  107. /// </para>
  108. /// </remarks>
  109. public const long DefaultMaxSize = 134217728;
  110. /// <summary>
  111. /// Asset's default expiration time in the cache.
  112. /// </summary>
  113. public static readonly TimeSpan DefaultExpirationTime = TimeSpan.FromMinutes(30.0);
  114. /// <summary>
  115. /// Log manager instance.
  116. /// </summary>
  117. private static readonly ILog Log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
  118. /// <summary>
  119. /// Cache object.
  120. /// </summary>
  121. private ICnmCache<string, AssetBase> m_cache;
  122. /// <summary>
  123. /// Count of cache commands
  124. /// </summary>
  125. private int m_cachedCount;
  126. /// <summary>
  127. /// How many gets before dumping statistics
  128. /// </summary>
  129. /// <remarks>
  130. /// If 0 or less, then disabled.
  131. /// </remarks>
  132. private int m_debugEpoch;
  133. /// <summary>
  134. /// Is Cenome asset cache enabled.
  135. /// </summary>
  136. private bool m_enabled;
  137. /// <summary>
  138. /// Count of get requests
  139. /// </summary>
  140. private int m_getCount;
  141. /// <summary>
  142. /// How many hits
  143. /// </summary>
  144. private int m_hitCount;
  145. /// <summary>
  146. /// Initialize asset cache module, with custom parameters.
  147. /// </summary>
  148. /// <param name="maximalSize">
  149. /// Cache's maximal size in bytes.
  150. /// </param>
  151. /// <param name="maximalCount">
  152. /// Cache's maximal count of assets.
  153. /// </param>
  154. /// <param name="expirationTime">
  155. /// Asset's expiration time.
  156. /// </param>
  157. protected void Initialize(long maximalSize, int maximalCount, TimeSpan expirationTime)
  158. {
  159. if (maximalSize <= 0 || maximalCount <= 0)
  160. {
  161. //Log.Debug("[ASSET CACHE]: Cenome asset cache is not enabled.");
  162. m_enabled = false;
  163. return;
  164. }
  165. if (expirationTime <= TimeSpan.Zero)
  166. {
  167. // Disable expiration time
  168. expirationTime = TimeSpan.MaxValue;
  169. }
  170. // Create cache and add synchronization wrapper over it
  171. m_cache =
  172. CnmSynchronizedCache<string, AssetBase>.Synchronized(new CnmMemoryCache<string, AssetBase>(
  173. maximalSize, maximalCount, expirationTime));
  174. m_enabled = true;
  175. Log.DebugFormat(
  176. "[ASSET CACHE]: Cenome asset cache enabled (MaxSize = {0} bytes, MaxCount = {1}, ExpirationTime = {2})",
  177. maximalSize,
  178. maximalCount,
  179. expirationTime);
  180. }
  181. #region IImprovedAssetCache Members
  182. /// <summary>
  183. /// Cache asset.
  184. /// </summary>
  185. /// <param name="asset">
  186. /// The asset that is being cached.
  187. /// </param>
  188. public void Cache(AssetBase asset)
  189. {
  190. if (asset != null)
  191. {
  192. long size = asset.Data != null ? asset.Data.Length : 1;
  193. m_cache.Set(asset.ID, asset, size);
  194. m_cachedCount++;
  195. }
  196. }
  197. /// <summary>
  198. /// Clear asset cache.
  199. /// </summary>
  200. public void Clear()
  201. {
  202. m_cache.Clear();
  203. }
  204. /// <summary>
  205. /// Expire (remove) asset stored to cache.
  206. /// </summary>
  207. /// <param name="id">
  208. /// The expired asset's id.
  209. /// </param>
  210. public void Expire(string id)
  211. {
  212. m_cache.Remove(id);
  213. }
  214. /// <summary>
  215. /// Get asset stored
  216. /// </summary>
  217. /// <param name="id">
  218. /// The asset's id.
  219. /// </param>
  220. /// <returns>
  221. /// Asset if it is found from cache; otherwise <see langword="null"/>.
  222. /// </returns>
  223. /// <remarks>
  224. /// <para>
  225. /// Caller should always check that is return value <see langword="null"/>.
  226. /// Cache doesn't guarantee in any situation that asset is stored to it.
  227. /// </para>
  228. /// </remarks>
  229. public AssetBase Get(string id)
  230. {
  231. m_getCount++;
  232. AssetBase assetBase;
  233. if (m_cache.TryGetValue(id, out assetBase))
  234. m_hitCount++;
  235. if (m_getCount == m_debugEpoch)
  236. {
  237. Log.DebugFormat(
  238. "[ASSET CACHE]: Cached = {0}, Get = {1}, Hits = {2}%, Size = {3} bytes, Avg. A. Size = {4} bytes",
  239. m_cachedCount,
  240. m_getCount,
  241. ((double) m_hitCount / m_getCount) * 100.0,
  242. m_cache.Size,
  243. m_cache.Size / m_cache.Count);
  244. m_getCount = 0;
  245. m_hitCount = 0;
  246. m_cachedCount = 0;
  247. }
  248. return assetBase;
  249. }
  250. #endregion
  251. #region ISharedRegionModule Members
  252. /// <summary>
  253. /// Gets region module's name.
  254. /// </summary>
  255. public string Name
  256. {
  257. get { return "CenomeMemoryAssetCache"; }
  258. }
  259. public Type ReplaceableInterface
  260. {
  261. get { return null; }
  262. }
  263. /// <summary>
  264. /// New region is being added to server.
  265. /// </summary>
  266. /// <param name="scene">
  267. /// Region's scene.
  268. /// </param>
  269. public void AddRegion(Scene scene)
  270. {
  271. if (m_enabled)
  272. scene.RegisterModuleInterface<IImprovedAssetCache>(this);
  273. }
  274. /// <summary>
  275. /// Close region module.
  276. /// </summary>
  277. public void Close()
  278. {
  279. m_enabled = false;
  280. m_cache.Clear();
  281. m_cache = null;
  282. }
  283. /// <summary>
  284. /// Initialize region module.
  285. /// </summary>
  286. /// <param name="source">
  287. /// Configuration source.
  288. /// </param>
  289. public void Initialise(IConfigSource source)
  290. {
  291. m_cache = null;
  292. m_enabled = false;
  293. IConfig moduleConfig = source.Configs[ "Modules" ];
  294. if (moduleConfig == null)
  295. return;
  296. string name = moduleConfig.GetString("AssetCaching");
  297. //Log.DebugFormat("[XXX] name = {0} (this module's name: {1}", name, Name);
  298. if (name != Name)
  299. return;
  300. // This module is used
  301. long maxSize = DefaultMaxSize;
  302. int maxCount = DefaultMaxCount;
  303. TimeSpan expirationTime = DefaultExpirationTime;
  304. IConfig assetConfig = source.Configs["AssetCache"];
  305. if (assetConfig != null)
  306. {
  307. // Get optional configurations
  308. maxSize = assetConfig.GetLong("MaxSize", DefaultMaxSize);
  309. maxCount = assetConfig.GetInt("MaxCount", DefaultMaxCount);
  310. expirationTime =
  311. TimeSpan.FromMinutes(assetConfig.GetInt("ExpirationTime", (int)DefaultExpirationTime.TotalMinutes));
  312. // Debugging purposes only
  313. m_debugEpoch = assetConfig.GetInt("DebugEpoch", 0);
  314. }
  315. Initialize(maxSize, maxCount, expirationTime);
  316. }
  317. /// <summary>
  318. /// Initialization post handling.
  319. /// </summary>
  320. /// <remarks>
  321. /// <para>
  322. /// Modules can use this to initialize connection with other modules.
  323. /// </para>
  324. /// </remarks>
  325. public void PostInitialise()
  326. {
  327. }
  328. /// <summary>
  329. /// Region has been loaded.
  330. /// </summary>
  331. /// <param name="scene">
  332. /// Region's scene.
  333. /// </param>
  334. /// <remarks>
  335. /// <para>
  336. /// This is needed for all module types. Modules will register
  337. /// Interfaces with scene in AddScene, and will also need a means
  338. /// to access interfaces registered by other modules. Without
  339. /// this extra method, a module attempting to use another modules'
  340. /// interface would be successful only depending on load order,
  341. /// which can't be depended upon, or modules would need to resort
  342. /// to ugly kludges to attempt to request interfaces when needed
  343. /// and unnecessary caching logic repeated in all modules.
  344. /// The extra function stub is just that much cleaner.
  345. /// </para>
  346. /// </remarks>
  347. public void RegionLoaded(Scene scene)
  348. {
  349. }
  350. /// <summary>
  351. /// Region is being removed.
  352. /// </summary>
  353. /// <param name="scene">
  354. /// Region scene that is being removed.
  355. /// </param>
  356. public void RemoveRegion(Scene scene)
  357. {
  358. }
  359. #endregion
  360. }
  361. }