forked from ClearFoundry/ClearScript
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathCanonicalRefTable.cs
More file actions
142 lines (116 loc) · 4.12 KB
/
CanonicalRefTable.cs
File metadata and controls
142 lines (116 loc) · 4.12 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT license.
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.ClearScript.Util;
namespace Microsoft.ClearScript
{
internal static class CanonicalRefTable
{
private static readonly object tableLock = new object();
private static readonly Dictionary<Type, ICanonicalRefMap> table = new Dictionary<Type, ICanonicalRefMap>();
public static object GetCanonicalRef(object obj)
{
if (obj is ValueType)
{
var map = GetMap(obj);
if (map != null)
{
obj = map.GetRef(obj);
}
}
return obj;
}
private static ICanonicalRefMap GetMap(object obj)
{
var type = obj.GetType();
lock (tableLock)
{
ICanonicalRefMap map;
if (!table.TryGetValue(type, out map))
{
if (type.IsEnum ||
type.IsNumeric() ||
type == typeof(DateTime) ||
type == typeof(DateTimeOffset) ||
type == typeof(TimeSpan) ||
type.GetCustomAttributes(typeof(ImmutableValueAttribute), false).Any())
{
map = (ICanonicalRefMap)typeof(CanonicalRefMap<>).MakeGenericType(type).CreateInstance();
}
table.Add(type, map);
}
return map;
}
}
#region Nested type: ICanonicalRefMap
private interface ICanonicalRefMap
{
object GetRef(object obj);
}
#endregion
#region Nested type: CanonicalRefMapBase
private abstract class CanonicalRefMapBase : ICanonicalRefMap
{
protected const int CompactionThreshold = 256 * 1024;
protected static readonly TimeSpan CompactionInterval = TimeSpan.FromMinutes(2);
#region ICanonicalRefMap implementation (abstract)
public abstract object GetRef(object obj);
#endregion
}
#endregion
#region Nested type: CanonicalRefMap<T>
private sealed class CanonicalRefMap<T> : CanonicalRefMapBase
{
private readonly object mapLock = new object();
private readonly Dictionary<T, WeakReference> map = new Dictionary<T, WeakReference>();
private DateTime lastCompactionTime = DateTime.MinValue;
private object GetRefInternal(object obj)
{
var value = (T)obj;
object result;
WeakReference weakRef;
if (map.TryGetValue(value, out weakRef))
{
result = weakRef.Target;
if (result == null)
{
result = obj;
weakRef.Target = result;
}
}
else
{
result = obj;
map.Add(value, new WeakReference(result));
}
return result;
}
private void CompactIfNecessary()
{
if (map.Count >= CompactionThreshold)
{
var now = DateTime.UtcNow;
if ((lastCompactionTime + CompactionInterval) <= now)
{
map.Where(pair => !pair.Value.IsAlive).ToList().ForEach(pair => map.Remove(pair.Key));
lastCompactionTime = now;
}
}
}
#region CanonicalRefMapBase overrides
public override object GetRef(object obj)
{
lock (mapLock)
{
var result = GetRefInternal(obj);
CompactIfNecessary();
return result;
}
}
#endregion
}
#endregion
}
}