implab/ImplabNet Commit - r92:4c0e5ef99986

rewritten tracing

cin -

r92:4c0e5ef99986 v2

parent child

Context file:

r92:4c0e5ef99986

Collapse all files

Implab/Diagnostics/Extensions.cs created 644 +15 0

@@ -0,0 +1,15
	1	namespace Implab.Diagnostics {
	2	public static class Extensions {
	3	public static IPromise<T> EndLogicalOperation<T>(this IPromise<T> promise) {
	4	Safe.ArgumentNotNull(promise, "promise");
	5	var op = TraceContext.Instance.DetachLogicalOperation();
	6
	7	return promise.Anyway(() => {
	8	TraceContext.Instance.EnterLogicalOperation(op,true);
	9	TraceLog.EndLogicalOperation();
	10	TraceContext.Instance.Leave();
	11	});
	12	}
	13	}
	14	}
	15

Implab/Diagnostics/LogEventArgs.cs created 644 +24 0

@@ -0,0 +1,24
	1	using System;
	2
	3	namespace Implab.Diagnostics {
	4	public class LogEventArgs : EventArgs {
	5	public int ThreadId {
	6	get;
	7	private set;
	8	}
	9	public LogicalOperation Operation {
	10	get;
	11	private set;
	12	}
	13	public int OperationTimeOffset {
	14	get;
	15	private set;
	16	}
	17	public LogEventArgs(int threadId, LogicalOperation operation, int timeOffset) {
	18	ThreadId = threadId;
	19	Operation = operation;
	20	OperationTimeOffset = timeOffset;
	21	}
	22	}
	23	}
	24

Implab/Diagnostics/LogEventArgsT.cs created 644 +13 0

@@ -0,0 +1,13
	1	namespace Implab.Diagnostics {
	2	public class LogEventArgs<TEvent> : LogEventArgs {
	3	public TEvent Value {
	4	get;
	5	private set;
	6	}
	7
	8	public LogEventArgs(TEvent value, int threadId, LogicalOperation operation, int timeOffset) : base(threadId, operation, timeOffset) {
	9	Value = value;
	10	}
	11	}
	12	}
	13

Implab/Diagnostics/OperationContext.cs created 644 +49 0

@@ -0,0 +1,49
	1	namespace Implab.Diagnostics {
	2	struct OperationContext {
	3	readonly LogicalOperation m_initial;
	4	public readonly static OperationContext EMPTY = new OperationContext(LogicalOperation.EMPTY, false);
	5	LogicalOperation m_current;
	6	readonly bool m_ownership;
	7
	8	public OperationContext(LogicalOperation operation, bool ownership) {
	9	Safe.ArgumentNotNull(operation, "operation");
	10
	11	m_initial = operation;
	12	m_current = operation;
	13	m_ownership = ownership;
	14	}
	15
	16	public LogicalOperation CurrentOperation {
	17	get { return m_current; }
	18	}
	19
	20	public void BeginLogicalOperation(string name) {
	21	m_current = new LogicalOperation(name, m_current);
	22	}
	23
	24	public LogicalOperation DetachLogicalOperation() {
	25	var detached = m_current;
	26	if (m_current != LogicalOperation.EMPTY) {
	27	if (m_current != m_initial)
	28	m_current = m_current.Parent;
	29	else if (m_ownership)
	30	m_current = LogicalOperation.EMPTY;
	31	else
	32	detached = LogicalOperation.EMPTY;
	33	}
	34	TraceLog.TraceWarning("EndLogicalOperation can't be applied in the current context");
	35	return detached;
	36	}
	37
	38	public void EndLogicalOperation() {
	39	if (m_current != m_initial) {
	40	m_current = m_current.Parent;
	41	} else if (m_current != null && m_ownership) {
	42	m_current = null;
	43	} else {
	44	TraceLog.TraceWarning("EndLogicalOperation can't be applied in the current context");
	45	}
	46	}
	47	}
	48	}
	49

Implab.Diagnostics.Interactive/InteractiveListener.cs +2 -2

                         base.Dispose(disposing);
                     }
-                    protected override void WriteEntry(TraceContext context, EventText text, string channel) {
+                    protected override void WriteEntry(LogEventArgs args, EventText text, string channel) {
                         var item = new TraceViewItem {
                             Indent = text.indent,
                             Message = text.content,
-                            Thread = context.ThreadId,
+                            Thread = args.ThreadId,
                             Channel = channel,
                             Timestamp = Environment.TickCount
                         };

Implab/Diagnostics/ConsoleTraceListener.cs +4 -4

                     }
-                    protected override void WriteEntry(TraceContext context, EventText text, string channel) {
+                    protected override void WriteEntry(LogEventArgs args, EventText text, string channel) {
                         var msg = new StringBuilder();
                         for (int i = 0; i < text.indent; i++)
                             msg.Append("  ");
-                        msg.AppendFormat("[{0}]:{1}: {2}", context.ThreadId, channel, text.content);
+                        msg.AppendFormat("[{0}]:{1}: {2}", args.ThreadId, channel, text.content);
                         lock (_consoleLock) {
-                            Console.ForegroundColor = (ConsoleColor)(context.ThreadId % 15 + 1);
+                            Console.ForegroundColor = (ConsoleColor)(args.ThreadId % 15 + 1);
-                            Console.WriteLine(msg.ToString());
+                            Console.WriteLine(msg);
                         }
                     }
                 }

Implab/Diagnostics/IEventTextFormatter.cs +2 -7

@@ -1,10 +1,5
1	using System;	1	namespace Implab.Diagnostics {
2	using System.Collections.Generic;
3	using System.Linq;
4	using System.Text;
5
6	namespace Implab.Diagnostics {
7	public interface IEventTextFormatter<in TEvent> {	2	public interface IEventTextFormatter<in TEvent> {
8	EventText Format(~~TraceContext~~ ~~context~~, TEvent data);	3	EventText Format(LogEventArgs args, TEvent data);
9	}	4	}
10	}	5	}

Implab/Diagnostics/LogChannel.cs +14 -15

                     /// <summary>
                     /// Событие появление новой записи в журнале, на это событие подписываются слушатели.
                     /// </summary>
-                    public event EventHandler<ValueEventArgs<TEvent>> Events;
+                    public event EventHandler<LogEventArgs<TEvent>> Events;
                     /// <summary>
                     /// Имя канала, полезно для отображения в журнале
                     /// </summary>
                     /// </remarks>
                     public void LogEvent(TEvent data) {
                         var t = Events;
-                        if (t!= null)
+                        if (t != null) {
-                            t(TraceContext.Current,new ValueEventArgs<TEvent>(data));
+                            var traceContext = TraceContext.Instance;
+                            t(
+                                this,
-                    /// <summary>
+                                new LogEventArgs<TEvent>(
-                    /// Отправляет запись журнала через канал подписчикам.
+                                    data,
-                    /// </summary>
+                                    traceContext.ThreadId,
-                    /// <param name="data">Запись журнала.</param>
+                                    traceContext.CurrentOperation,
-                    /// <param name="context">Контекст трассировки от которого рассылается сообщение/</param>
+                                    traceContext.CurrentOperation.Duration
-                    public void LogEvent(TraceContext context,TEvent data) {
-                        var t = Events;
+                            );
-                        if (t != null)
-                            t(context, new ValueEventArgs<TEvent>(data));
                     }
                 }
             }

Implab/Diagnostics/LogicalOperation.cs +2 -4

             using System;
-            using System.Collections.Generic;
-            using System.Linq;
-            using System.Text;
-            using System.Threading.Tasks;
             namespace Implab.Diagnostics {
                 public class LogicalOperation {
+                    public static readonly LogicalOperation EMPTY = new LogicalOperation("__EMPTY__", null);
                     readonly LogicalOperation m_parent;
                     readonly string m_name;
                     readonly int m_level;

Implab/Diagnostics/TextFileListener.cs +3 -5

             using System;
-            using System.Collections.Generic;
             using System.IO;
-            using System.Linq;
             using System.Text;
             namespace Implab.Diagnostics {
                         Register(this);
                     }
-                    protected override void WriteEntry(TraceContext context, EventText text, string channel) {
+                    protected override void WriteEntry(LogEventArgs args, EventText text, string channel) {
                         var msg = new StringBuilder();
                         for (int i = 0; i < text.indent; i++)
                             msg.Append("  ");
-                        msg.AppendFormat("[{0}]:{1}: {2}", context.ThreadId, channel, text.content);
+                        msg.AppendFormat("[{0}]:{1}: {2}", args.ThreadId, channel, text.content);
                         lock (m_textWriter) {
                             if (!IsDisposed) {
                                 // тут гарантировано еще не освобожден m_textWriter
-                                m_textWriter.WriteLine(msg.ToString());
+                                m_textWriter.WriteLine(msg);
                                 m_textWriter.Flush();
                             }
                         }

Implab/Diagnostics/TextListenerBase.cs +11 -12

                     protected TextListenerBase(bool global) {
                         Register(this);
                         if (!global) {
-                            m_boundOperation = TraceContext.Current.CurrentOperation;
+                            m_boundOperation = TraceContext.Instance.CurrentOperation;
                             m_baseIndent = Math.Max(0, m_boundOperation.Level - 1);
                         }
                     }
                             var formatter = GetService<IEventTextFormatter<TEvent>>();
                             var channelName = channel.Name;
-                            EventHandler<ValueEventArgs<TEvent>> handler = (sender, args) => {
+                            EventHandler<LogEventArgs<TEvent>> handler = (sender, args) => {
-                                TraceContext context = (TraceContext)sender;
+                                var text = formatter.Format(args, args.Value);
-                                var text = formatter.Format(context, args.Value);
                                 text.indent -= m_baseIndent;
-                                if (IsRelated(context.CurrentOperation))
+                                if (IsRelated(args.Operation))
-                                    WriteEntry(context, text, channelName);
+                                    WriteEntry(args, text, channelName);
                             };
                             if (m_subscriptions.ContainsKey(channel))
                     /// Данный метод может вызваться из разных потоков одновременно. Возможна ситуация, когда
                     /// данный метод вызывается уже после освобождения ообъекта методом <see cref="Dispose()"/>.
                     /// </remarks>
-                    /// <param name="context">Контекст трассировки.</param>
                     /// <param name="text">Текст сообщения.</param>
-                    protected abstract void WriteEntry(TraceContext context, EventText text, string channel);
+                    /// <param name = "channel"></param>
+                    protected abstract void WriteEntry(LogEventArgs args, EventText text, string channel);
-                    public EventText Format(TraceContext context, object data) {
+                    public EventText Format(LogEventArgs args, object data) {
                         return new EventText {
-                            indent = context.CurrentOperation.Level,
+                            indent = args.Operation.Level,
                             content = data.ToString()
                         };
                     }
-                    public EventText Format(TraceContext context, TraceEvent data) {
+                    public EventText Format(LogEventArgs args, TraceEvent data) {
-                        var level = context.CurrentOperation.Level;
+                        var level = args.Operation.Level;
                         if (data.EventType == TraceEventType.OperationCompleted || data.EventType == TraceEventType.OperationStarted)
                             level--;

Implab/Diagnostics/TraceContext.cs +79 -238

@@ -1,238 +1,79
1	using System;	1	using System;
2	using System.Collections.Generic;	2	using System.Collections.Generic;
3	using System.~~Linq~~;	3	using System.Threading;
4	using System.Text;	4
5	using System.Threading;	5	namespace Implab.Diagnostics {
6	using System.Threading.Tasks;	6	/// <summary>
7		7	/// Trace context is bound to the specific thread, each thread has it's own ThreadContext.
8	namespace Implab.Diagnostics {	8	/// </summary>
9	/// <~~summary~~>	9	/// <remarks>
10	/// Контекст трассировки, привязывается к потоку и содержит в себе информацию о стеке логических операций.	10	/// ThreadContext manages relations between logical operations and threads.
11	/// </~~summary~~>	11	/// </remarks>
12	/// <remarks>	12	public class TraceContext {
13	/// Контекст трассировки передается слушателям событий для определения места, где возникло событие.	13
14	/// </remarks>	14	[ThreadStatic]
15	public class TraceContext {	15	static TraceContext _instance;
16	LogicalOperation m_currentOperation;	16
17	readonly LogicalOperation m_bound;	17	OperationContext m_current = OperationContext.EMPTY;
18	readonly int m_threadId;	18	readonly Stack<OperationContext> m_stack = new Stack<OperationContext>();
19		19	readonly int m_threadId;
20	[ThreadStatic]	20
21	static TraceContext ~~_current~~;	21	public static TraceContext Instance {
22		22	get {
23	/// <summary>	23	if (_instance == null)
24	/// Текущий контекст трассировки для потока, создается астоматически при первом обращении.	24	_instance = new TraceContext();
25	/// </summary>	25	return _instance;
26	public static TraceContext Current {	26	}
27	~~get~~ {	27	}
28	if (_current == null) {	28
29	_current = new TraceContext();	29	public TraceContext() {
30	_current.LogEvent(TraceEventType.Created,"[{0}]", _current.ThreadId);	30	m_threadId = Thread.CurrentThread.ManagedThreadId;
31	}	31	}
32	return _current;	32
33	}	33	public int ThreadId {
34	}	34	get { return m_threadId; }
35		35	}
36	TraceContext(TraceContext context)	36
37	: this(context, false) {	37	public LogicalOperation CurrentOperation {
38	}	38	get {
39		39	return m_current.CurrentOperation;
40	TraceContext(TraceContext context, bool attach) {	40	}
41	if (context == null)	41	}
42	throw new ArgumentNullException("context");	42
43		43	public void EnterLogicalOperation(LogicalOperation operation, bool takeOwnership) {
44	m_currentOperation = context.CurrentOperation;	44	// TODO Emit event
45	m_bound = attach ? context.BoundOperation : context.CurrentOperation;	45	m_stack.Push(m_current);
46	m_threadId = Thread.CurrentThread.ManagedThreadId;	46	m_current = new OperationContext(operation, takeOwnership);
47	}	47	}
48		48
49	TraceContext() {	49	public void StartLogicalOperation(string name) {
50	m_current~~Operation~~ = ~~new~~ LogicalOperation();	50	m_current.BeginLogicalOperation(name);
51	m_bound = m_currentOperation;	51	}
52	m_threadId = Thread.CurrentThread.ManagedThreadId;	52
53	}	53	public void StartLogicalOperation() {
54		54	// TODO Emit Event
55	/// <summary>	55	m_current.BeginLogicalOperation(String.Empty);
56	/// При необходимости копирует состояние контекста трассивровки в текущий поток.	56	}
57	/// </summary>	57
58	/// <param name="from">Исходный контекст трассировки, который передается.</param>	58	public void EndLogicalOperation() {
59	/// <remarks>	59	// TODO Emit event
60	/// <para>	60	m_current.EndLogicalOperation();
61	/// Копирование происходит за счет создания нового контекста трассировки и заполнением его	61	}
62	/// состояния из переданного контекста. При этом копируется стек операций, однако в новом	62
63	/// контексте ранее начатые логические операции не могут быть завершены.	63	public LogicalOperation DetachLogicalOperation() {
64	/// </para>	64	// TODO Emit event
65	/// <para>	65	return m_current.DetachLogicalOperation();
66	/// Если передача состояния состоялась, то вызывается событие трассировки <see cref="TraceEventType.Fork"/>.	66	}
67	/// </para>	67
68	/// </remarks>	68	public void Leave() {
69	public static void Fork(TraceContext from) {	69	// TODO Emit event
70	if (_cu~~rre~~nt == ~~from~~)	70	if (m_stack.Count > 0)
71	~~return~~;	71	m_current = m_stack.Pop();
72	if (~~from~~ != ~~null~~) {	72	else {
73	var context = new TraceContext(from);	73	TraceLog.TraceWarning("Attemtp to leave the last operation context");
74	context.LogEvent(TraceEventType.Fork, "[{0}]-->[{1}]",from.ThreadId, context.ThreadId);	74	m_current = OperationContext.EMPTY;
75	_current = context;	75	}
76	} ~~else~~ {	76	}
77	_current = new TraceContext();	77	}
78	}	78	}
79	}	79
80
81	/// <summary>
82	/// Задает текущему потоку указанный контекст, текущей поток может заканчивать ранее начатые
83	/// логические операции в указанном контексте.
84	/// </summary>
85	/// <param name="source"></param>
86	public static void Attach(TraceContext source) {
87	if (_current == source)
88	return;
89	if (source != null) {
90	var context = new TraceContext(source, true);
91	context.LogEvent(TraceEventType.Attach, "[{0}]-->[{1}]", source.ThreadId, context.ThreadId);
92	_current = context;
93	} else {
94	_current = new TraceContext();
95	}
96	}
97
98	/// <summary>
99	/// Отсоединяет текущий контекст трассировки от потока, для дальнейшей его передачи другому потоку
100	/// <see cref="Attach(TraceContext)"/>.
101	/// </summary>
102	/// <returns>Контекст трассировки потока</returns>
103	/// <remarks>
104	/// После отсоединения контекста трассировки от потока, при первом обращении к трассировке в этом
105	/// потоке будет создан новый контекст.
106	/// </remarks>
107	public static TraceContext Detach() {
108	var context = Current;
109	context.LogEvent(TraceEventType.Detach, null);
110	_current = null;
111	return context;
112	}
113
114	/// <summary>
115	/// Создает постоянную копию текущего контекста, данную копию можно хранить и использовать для передачи через <see cref="Fork(TraceContext)"/>
116	/// </summary>
117	/// <returns>Копия текущего контекста трассировки.</returns>
118	public static TraceContext Snapshot() {
119	return _current == null ? new TraceContext() : new TraceContext(_current,false);
120	}
121
122	/// <summary>
123	/// Выполняет переданное действие в указанном контексте трассировки, по окончании восстанавливает предыдущий контекст трассировки потока.
124	/// </summary>
125	/// <param name="action"></param>
126	public void Invoke(Action action) {
127	if (action == null)
128	throw new ArgumentNullException("action");
129	var old = _current;
130	Fork(this);
131	try {
132	action();
133	} finally {
134	if(_current != null)
135	_current.EndAllOperations();
136	_current = old;
137	}
138	}
139
140	/// <summary>
141	/// Текущая логическая операция.
142	/// </summary>
143	public LogicalOperation CurrentOperation {
144	get {
145	return m_currentOperation;
146	}
147	}
148
149	/// <summary>
150	/// Операция ниже которой нельзя опускаться в стеке логических операций, т.е. она не может быть завершена в текущем контексте.
151	/// </summary>
152	public LogicalOperation BoundOperation {
153	get {
154	return m_bound;
155	}
156	}
157
158	/// <summary>
159	/// Поток, в котором создан контекст трассировки.
160	/// </summary>
161	public int ThreadId {
162	get {
163	return m_threadId;
164	}
165	}
166
167	/// <summary>
168	/// Начинает безымянную логическую операцию.
169	/// </summary>
170	public void StartLogicalOperation() {
171	StartLogicalOperation(null);
172	}
173
174	/// <summary>
175	/// Начинает логическую операцию с указанным именем. Созданная операция будет добвалена в стек логических операций контекста, затем будет создано соответсвующее событие.
176	/// </summary>
177	/// <param name="name">Имя начинаемой операции.</param>
178	public void StartLogicalOperation(string name) {
179	m_currentOperation = new LogicalOperation(name, m_currentOperation);
180	LogEvent(TraceEventType.OperationStarted, name);
181	}
182
183	/// <summary>
184	/// Заканчивает логическую операцию начатую в текущем контексте. Операции, начатые в других контекстах не могут быть закончены в текущем контексте.
185	/// </summary>
186	/// <remarks>
187	/// При вызове данного метода создается событие журнала трассировки, либо о завершении операции, либо об ошибки, поскольку данная операция
188	/// начата в другом контексте.
189	/// </remarks>
190	public void EndLogicalOperation() {
191	if (m_bound == m_currentOperation) {
192	LogEvent(TraceEventType.Error, "Trying to end the operation which isn't belongs to current trace");
193	} else {
194	var op = m_currentOperation;
195	LogEvent(TraceEventType.OperationCompleted, "{0} {1} ms", op.Name, op.Duration);
196	m_currentOperation = m_currentOperation.Parent;
197	}
198	}
199
200	/// <summary>
201	/// Создает копию контекста и возвращается на предыдущую операцию в текущем контексте, это позволяет начать операцию в одном потоке, а завершить - в другом.
202	/// </summary>
203	/// <returns>Контекст трассировки, который можно присоединить к другому потоку.</returns>
204	public TraceContext DetachLogicalOperation() {
205	if (m_bound == m_currentOperation) {
206	return new TraceContext();
207	} else {
208	var detached = new TraceContext(this, true);
209	m_currentOperation = m_currentOperation.Parent;
210	return detached;
211	}
212	}
213
214	public void BindLogicalOperationToPromise(IPromise promise) {
215	Safe.ArgumentNotNull(promise, "promise");
216
217	var ctx = DetachLogicalOperation();
218	promise.Anyway(() => {
219	var old = _current;
220	TraceContext.Attach(ctx);
221	TraceContext.Current.EndLogicalOperation();
222	_current = old;
223	});
224	}
225
226	/// <summary>
227	/// Заврешает все начатые в этом контексте операции
228	/// </summary>
229	public void EndAllOperations() {
230	while (m_bound != m_currentOperation)
231	EndLogicalOperation();
232	}
233
234	void LogEvent(TraceEventType type, string format, params object[] args) {
235	LogChannel<TraceEvent>.Default.LogEvent(this, TraceEvent.Create(type, format, args));
236	}
237	}
238	}

Implab/Diagnostics/TraceLog.cs +3 -8

                 public static class TraceLog {
                     [Conditional("TRACE")]
                     public static void StartLogicalOperation() {
-                        TraceContext.Current.StartLogicalOperation();
+                        TraceContext.Instance.StartLogicalOperation();
                     }
                     [Conditional("TRACE")]
                     public static void StartLogicalOperation(string name) {
-                        TraceContext.Current.StartLogicalOperation(name);
+                        TraceContext.Instance.StartLogicalOperation(name);
                     }
                     [Conditional("TRACE")]
                     public static void EndLogicalOperation() {
-                        TraceContext.Current.EndLogicalOperation();
+                        TraceContext.Instance.EndLogicalOperation();
-                    [Conditional("TRACE")]
-                    public static void BindLogicalOperationToPromise(IPromise promise) {
-                        TraceContext.Current.BindLogicalOperationToPromise(promise);
                     }
                     [Conditional("TRACE")]

Implab/Implab.csproj +5 -1

                 <Compile Include="Diagnostics\TextFileListener.cs" />
                 <Compile Include="Diagnostics\TextListenerBase.cs" />
                 <Compile Include="Diagnostics\TraceLog.cs" />
-                <Compile Include="Diagnostics\TraceContext.cs" />
                 <Compile Include="Diagnostics\TraceEvent.cs" />
                 <Compile Include="Diagnostics\TraceEventType.cs" />
                 <Compile Include="Disposable.cs" />
                 <Compile Include="TransientPromiseException.cs" />
                 <Compile Include="SyncContextPromise.cs" />
                 <Compile Include="ObjectPool.cs" />
+                <Compile Include="Diagnostics\OperationContext.cs" />
+                <Compile Include="Diagnostics\TraceContext.cs" />
+                <Compile Include="Diagnostics\LogEventArgs.cs" />
+                <Compile Include="Diagnostics\LogEventArgsT.cs" />
+                <Compile Include="Diagnostics\Extensions.cs" />
               </ItemGroup>
               <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
               <ItemGroup />

Implab/Parallels/ArrayTraits.cs +17 -9

                         readonly Action<TSrc> m_action;
                         readonly TSrc[] m_source;
                         readonly Promise<int> m_promise = new Promise<int>();
-                        readonly TraceContext m_traceContext;
+                        readonly LogicalOperation m_logicalOperation;
                         int m_pending;
                         int m_next;
                             Debug.Assert(source != null);
                             Debug.Assert(action != null);
-                            m_traceContext = TraceContext.Snapshot();
+                            m_logicalOperation = TraceContext.Instance.CurrentOperation;
                             m_next = 0;
                             m_source = source;
                             m_pending = source.Length;
                         }
                         protected override void Worker() {
-                            TraceContext.Fork(m_traceContext);
+                            TraceContext.Instance.EnterLogicalOperation(m_logicalOperation, false);
-                            base.Worker();
+                            try {
+                                base.Worker();
+                            } finally {
+                                TraceContext.Instance.Leave();
+                            }
                         }
                         protected override bool TryDequeue(out int unit) {
                         readonly TSrc[] m_source;
                         readonly TDst[] m_dest;
                         readonly Promise<TDst[]> m_promise = new Promise<TDst[]>();
-                        readonly TraceContext m_traceContext;
+                        readonly LogicalOperation m_logicalOperation;
                         int m_pending;
                         int m_next;
                             m_dest = new TDst[source.Length];
                             m_pending = source.Length;
                             m_transform = transform;
-                            m_traceContext = TraceContext.Snapshot();
+                            m_logicalOperation = TraceContext.Instance.CurrentOperation;
                             m_promise.Anyway(Dispose);
                         }
                         protected override void Worker() {
-                            TraceContext.Fork(m_traceContext);
+                            TraceContext.Instance.EnterLogicalOperation(m_logicalOperation,false);
-                            base.Worker();
+                            try {
+                                base.Worker();
+                            } finally {
+                                TraceContext.Instance.Leave();
+                            }
                         }
                         protected override bool TryDequeue(out int unit) {
                             unit = Interlocked.Increment(ref m_next) - 1;
-                            return unit >= m_source.Length ? false : true;
+                            return unit < m_source.Length;
                         }
                         protected override void InvokeUnit(int unit) {

Implab/Parallels/AsyncPool.cs +13 -7

             		public static IPromise<T> Invoke<T>(Func<T> func) {
             			var p = new Promise<T>();
-                        var caller = TraceContext.Snapshot();
+                        var caller = TraceContext.Instance.CurrentOperation;
             			ThreadPool.QueueUserWorkItem(param => {
-                            TraceContext.Fork(caller);
+                            TraceContext.Instance.EnterLogicalOperation(caller,false);
             				try {
             					p.Resolve(func());
             				} catch(Exception e) {
             					p.Reject(e);
+                            } finally {
+                                TraceContext.Instance.Leave();
+                            }
             			});
             			return p;
                     public static IPromise<T> InvokeNewThread<T>(Func<T> func) {
                         var p = new Promise<T>();
-                        var caller = TraceContext.Snapshot();
+                        var caller = TraceContext.Instance.CurrentOperation;
                         var worker = new Thread(() => {
-                            TraceContext.Fork(caller);
+                            TraceContext.Instance.EnterLogicalOperation(caller,false);
                             try {
                                 p.Resolve(func());
                             } catch (Exception e) {
                                 p.Reject(e);
+                            } finally {
+                                TraceContext.Instance.Leave();
                             }
                         });
                         worker.IsBackground = true;
                     public static IPromise InvokeNewThread(Action func) {
                         var p = new Promise<object>();
-                        var caller = TraceContext.Snapshot();
+                        var caller = TraceContext.Instance.CurrentOperation;
                         var worker = new Thread(() => {
-                            TraceContext.Fork(caller);
+                            TraceContext.Instance.EnterLogicalOperation(caller,false);
                             try {
                                 func();
                                 p.Resolve();
                             } catch (Exception e) {
                                 p.Reject(e);
+                            } finally {
+                                TraceContext.Instance.Leave();
                             }
                         });
                         worker.IsBackground = true;

Implab/Parallels/DispatchPool.cs +2 -7

             using System;
-            using System.Collections.Generic;
-            using System.Linq;
-            using System.Text;
             using System.Threading;
-            using System.Diagnostics;
             namespace Implab.Parallels {
                 public abstract class DispatchPool<TUnit> : IDisposable {
                     protected bool StartWorker() {
                         if (AllocateThreadSlot()) {
                             // slot successfully allocated
-                            var worker = new Thread(this.Worker);
+                            var worker = new Thread(Worker);
                             worker.IsBackground = true;
                             worker.Start();
                             return true;
-                        } else {
-                            return false;
                         }
+                        return false;
                     }
                     protected abstract void InvokeUnit(TUnit unit);

Implab/Parallels/WorkerPool.cs +10 -17

             using System;
-            using System.Collections.Generic;
-            using System.Linq;
-            using System.Text;
             using System.Threading;
             using System.Diagnostics;
             using Implab.Diagnostics;
                     MTQueue<Action> m_queue = new MTQueue<Action>();
                     int m_queueLength = 0;
                     readonly int m_threshold = 1;
-                    int m_workers = 0;
                     public WorkerPool(int minThreads, int maxThreads, int threshold)
                         : base(minThreads, maxThreads) {
                         m_threshold = threshold;
-                        m_workers = minThreads;
                         InitPool();
                     }
                     public WorkerPool(int minThreads, int maxThreads) :
                         base(minThreads, maxThreads) {
-                        m_workers = minThreads;
                         InitPool();
                     }
                     public WorkerPool(int threads)
                         : base(threads) {
-                        m_workers = threads;
                         InitPool();
                     }
-                    public WorkerPool()
+                    public WorkerPool() {
-                        : base() {
                         InitPool();
                     }
                         var promise = new Promise<T>();
-                        var caller = TraceContext.Snapshot();
+                        var lop = TraceContext.Instance.CurrentOperation;
                         EnqueueTask(delegate() {
-                            caller.Invoke(delegate() {
+                            TraceContext.Instance.EnterLogicalOperation(lop, false);
-                                try {
+                            try {
-                                    promise.Resolve(task());
+                                promise.Resolve(task());
-                                } catch (Exception e) {
+                            } catch (Exception e) {
-                                    promise.Reject(e);
+                                promise.Reject(e);
+                            } finally {
-                            });
+                                TraceContext.Instance.Leave();
+                            }
                         });
                         return promise;

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages