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

             using Implab.Parallels;
             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Threading;
             using System.Threading.Tasks;
             using System.Windows.Forms;
             namespace Implab.Diagnostics.Interactive
             {
                 public class InteractiveListener: TextListenerBase
                 {
                     TraceForm m_form;
                     SynchronizationContext m_syncGuiThread;
                     readonly Promise<object> m_guiStarted = new Promise<object>();
                     readonly IPromise m_guiFinished;
                     //        readonly IPromise m_workerFinished = new Promise<object>();
                     readonly MTQueue<TraceViewItem> m_queue = new MTQueue<TraceViewItem>();
                     readonly AutoResetEvent m_queueEvent = new AutoResetEvent(false);
                     int m_queueLength;
                     bool m_exitPending;
                     readonly object m_pauseLock = new object();
                     bool m_paused;
                     readonly ManualResetEvent m_pauseEvent = new ManualResetEvent(true);
                     public InteractiveListener(bool global) : base(global) {
                         m_guiFinished = AsyncPool.InvokeNewThread(GuiThread);
                         /*m_workerFinished = */AsyncPool.InvokeNewThread(QueueThread);
                         m_guiStarted.Join();
                     }
                     void GuiThread() {
                         m_form = new TraceForm(); // will create SynchronizationContext
                         m_form.PauseEvents += (s,a) => Pause();
                         m_form.ResumeEvents += (s, a) => Resume();
                         m_syncGuiThread = SynchronizationContext.Current;
                         m_guiStarted.Resolve();
                         Application.Run();
                     }
                     void QueueThread() {
                         while (!m_exitPending) {
                             if (m_paused)
                                 m_pauseEvent.WaitOne();
                             TraceViewItem item;
                             if (m_queue.TryDequeue(out item)) {
                                 Interlocked.Decrement(ref m_queueLength);
                                 m_syncGuiThread.Send(x => m_form.AddTraceEvent(item),null);
                             } else {
                                 m_queueEvent.WaitOne();
                             }
                         }
                     }
                     public void Pause() {
                         // for consistency we need to set this properties atomically
                         lock (m_pauseLock) {
                             m_pauseEvent.Reset();
                             m_paused = true;
                         }
                     }
                     public void Resume() {
                         // for consistency we need to set this properties atomically
                         lock (m_pauseLock) {
                             m_paused = false;
                             m_pauseEvent.Set();
                         }
                     }
                     void Enqueue(TraceViewItem item) {
                         m_queue.Enqueue(item);
                         if (Interlocked.Increment(ref m_queueLength) == 1)
                             m_queueEvent.Set();
                     }
                     public void ShowForm() {
                         m_syncGuiThread.Post(x => m_form.Show(), null);
                     }
                     public void HideForm() {
                         m_syncGuiThread.Post(x => m_form.Hide(), null);
                     }
                     void Terminate() {
                         m_exitPending = true;
                         Resume();
                         m_syncGuiThread.Post(x => Application.ExitThread(), null);
                     }
                     protected override void Dispose(bool disposing) {
                         if (disposing) {
                             Terminate();
                             m_guiFinished.Join();
                         }
                         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
                         };
                         Enqueue(item);
                     }
                 }
             }

Implab/Diagnostics/ConsoleTraceListener.cs +4 -4

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             namespace Implab.Diagnostics {
                 public class ConsoleTraceListener: TextListenerBase {
                     static readonly object _consoleLock = new object();
                     public ConsoleTraceListener()
                         : base(true) {
                     }
                     public ConsoleTraceListener(bool global)
                         : base(global) {
                     }
-                    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

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             namespace Implab.Diagnostics {
                 /// <summary>
                 /// Канал, через который публикуются события журнала.
                 /// </summary>
                 /// <typeparam name="TEvent">Тип событий в канале</typeparam>
                 /// <remarks>
                 /// Событиями журнала могут быть любые типы, например строки, в которых будет передаваться
                 /// информация, или структуры с набором полей, описывающих  важность, текст и другую информацию.
                 /// </remarks>
                 public class LogChannel<TEvent> {
                     static LogChannel<TEvent> _default = new LogChannel<TEvent>();
                     /// <summary>
                     /// Канал по-умолчанию для событий типа <typeparam name="TEvent"/>.
                     /// </summary>
                     public static LogChannel<TEvent> Default {
                         get {
                             return _default;
                         }
                     }
                     /// <summary>
                     /// Событие появление новой записи в журнале, на это событие подписываются слушатели.
                     /// </summary>
-                    public event EventHandler<ValueEventArgs<TEvent>> Events;
+                    public event EventHandler<LogEventArgs<TEvent>> Events;
                     /// <summary>
                     /// Имя канала, полезно для отображения в журнале
                     /// </summary>
                     public string Name {
                         get;
                         private set;
                     }
                     /// <summary>
                     /// Создает журнал, имя типа событий назначается в качетве имени канала.
                     /// </summary>
                     public LogChannel()
                         : this(null) {
                     }
                     /// <summary>
                     /// Содает канал с указанным именем.
                     /// </summary>
                     /// <param name="name">Имя канала.</param>
                     public LogChannel(string name) {
                         if (String.IsNullOrEmpty(name))
                             name = typeof(TEvent).Name;
                         Name = name;
                     }
                     /// <summary>
                     /// Отправляет запись журнала через канал подписчикам.
                     /// </summary>
                     /// <param name="data">Запись журнала.</param>
                     /// <remarks>
                     /// Контекст трассировки от которого рассылается сообщение определяется автоматически из текущего потока.
                     /// </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;
                     readonly int m_timestamp;
                     public LogicalOperation()
                         : this(null, null) {
                     }
                     public LogicalOperation(string name, LogicalOperation parent) {
                         m_name = name ?? String.Empty;
                         m_parent = parent;
                         m_level = parent == null ? 0 : parent.Level + 1;
                         m_timestamp = Environment.TickCount;
                     }
                     public int Duration {
                         get {
                             var dt = Environment.TickCount - m_timestamp;
                             return dt < 0 ? int.MaxValue + dt : dt; // handle overflow
                         }
                     }
                     public LogicalOperation Parent {
                         get {
                             return m_parent;
                         }
                     }
                     public int Level {
                         get { return m_level; }
                     }
                     public string Name {
                         get { return m_name; }
                     }
                 }
             }

Implab/Diagnostics/TextFileListener.cs +3 -5

             using System;
-            using System.Collections.Generic;
             using System.IO;
-            using System.Linq;
             using System.Text;
             namespace Implab.Diagnostics {
                 public class TextFileListener: TextListenerBase {
                     readonly TextWriter m_textWriter;
                     public TextFileListener(string fileName, bool global)
                         : base(global) {
                         m_textWriter = File.CreateText(fileName);
                         m_textWriter.WriteLine("LOG {0}", DateTime.Now);
                         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();
                             }
                         }
                     }
                     protected override void Dispose(bool disposing) {
                         base.Dispose(disposing);
                         if (disposing) {
                             // IsDisposed = true
                             lock (m_textWriter) {
                                 Safe.Dispose(m_textWriter);
                             }
                         }
                     }
                 }
             }

Implab/Diagnostics/TextListenerBase.cs +11 -12

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             namespace Implab.Diagnostics {
                 public abstract class TextListenerBase : ServiceLocator, IEventTextFormatter<object>, IEventTextFormatter<TraceEvent> {
                     readonly Dictionary<object, Action> m_subscriptions = new Dictionary<object, Action>();
                     readonly LogicalOperation m_boundOperation;
                     readonly int m_baseIndent;
                     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);
                         }
                     }
                     public void Subscribe(Type eventType) {
                         if (eventType == null)
                             throw new ArgumentNullException("eventType");
                         GetType().GetMethod("Subscribe", new Type[0]).MakeGenericMethod(eventType).Invoke(this, null);
                     }
                     public void Subscribe<TEvent>() {
                         Subscribe<TEvent>(LogChannel<TEvent>.Default);
                     }
                     public void Subscribe<TEvent>(LogChannel<TEvent> channel) {
                         if (channel == null)
                             throw new ArgumentNullException("channel");
                         lock (m_subscriptions) {
                             AssertNotDisposed();
                             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))
                                 return;
                             channel.Events += handler;
                             Action unsubscribe = () => {
                                 channel.Events -= handler;
                             };
                             m_subscriptions.Add(channel, unsubscribe);
                         }
                     }
                     public bool IsRelated(LogicalOperation op) {
                         if (m_boundOperation == null)
                             return true;
                         while (op != m_boundOperation && op.Level > m_boundOperation.Level)
                             op = op.Parent;
                         return op == m_boundOperation;
                     }
                     public void Unsubscribe<TEvent>(LogChannel<TEvent> channel) {
                         if (channel == null)
                             throw new ArgumentNullException("channel");
                         lock (m_subscriptions) {
                             Action subscription;
                             if (m_subscriptions.TryGetValue(channel, out subscription)) {
                                 subscription();
                                 m_subscriptions.Remove(channel);
                             }
                         }
                     }
                     public void UnsubscribeAll() {
                         lock (m_subscriptions) {
                             foreach (var subscription in m_subscriptions.Values)
                                 subscription();
                             m_subscriptions.Clear();
                         }
                     }
                     /// <summary>
                     /// Вызывается для записи текста сообщения, в журнал.
                     /// </summary>
                     /// <remarks>
                     /// Данный метод может вызваться из разных потоков одновременно. Возможна ситуация, когда
                     /// данный метод вызывается уже после освобождения ообъекта методом <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--;
                         return new EventText {
                             indent = level,
                             content = data.ToString()
                         };
                     }
                     protected override void Dispose(bool disposing) {
                         base.Dispose(disposing);
                         if (disposing) {
                             UnsubscribeAll();
                         }
                     }
                 }
             }

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

             using System;
             using System.Collections.Generic;
             using System.Diagnostics;
             using System.Linq;
             using System.Text;
             using System.Threading.Tasks;
             namespace Implab.Diagnostics {
                 /// <summary>
                 /// Класс для публикации событий выполнения программы, события публикуются через <see cref="LogChannel{TraceEvent}"/>.
                 /// Журнал трассировки отражает логический ход выполнения программы и существует всегда, поскольку тесно связан с
                 /// контекстом трассировки.
                 /// </summary>
                 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")]
                     public static void TraceInformation(string format, params object[] arguments) {
                         LogChannel<TraceEvent>.Default.LogEvent(TraceEvent.Create(TraceEventType.Information, format, arguments));
                     }
                     [Conditional("TRACE")]
                     public static void TraceWarning(string format, params object[] arguments) {
                         LogChannel<TraceEvent>.Default.LogEvent(TraceEvent.Create(TraceEventType.Warning, format, arguments));
                     }
                     [Conditional("TRACE")]
                     public static void TraceError(string format, params object[] arguments) {
                         LogChannel<TraceEvent>.Default.LogEvent(TraceEvent.Create(TraceEventType.Error, format, arguments));
                     }
                     [Conditional("TRACE")]
                     public static void TraceError(Exception err) {
                         TraceError("{0}", err);
                     }
                 }
             }

Implab/Implab.csproj +5 -1

             <?xml version="1.0" encoding="utf-8"?>
             <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
               <PropertyGroup>
                 <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
                 <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
                 <ProjectGuid>{F550F1F8-8746-4AD0-9614-855F4C4B7F05}</ProjectGuid>
                 <OutputType>Library</OutputType>
                 <RootNamespace>Implab</RootNamespace>
                 <AssemblyName>Implab</AssemblyName>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>TRACE;DEBUG;</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
                 <RunCodeAnalysis>true</RunCodeAnalysis>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
                 <DebugType>full</DebugType>
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release</OutputPath>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug 4.5|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>TRACE;DEBUG;NET_4_5</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <RunCodeAnalysis>true</RunCodeAnalysis>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release 4.5|AnyCPU' ">
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release</OutputPath>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
                 <DefineConstants>NET_4_5</DefineConstants>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'DebugMono|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>TRACE;DEBUG;NET_4_5;MONO</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <RunCodeAnalysis>true</RunCodeAnalysis>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'ReleaseMono|AnyCPU' ">
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release</OutputPath>
                 <DefineConstants>NET_4_5;MONO;</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <ItemGroup>
                 <Reference Include="System" />
                 <Reference Include="System.Xml" />
               </ItemGroup>
               <ItemGroup>
                 <Compile Include="Component.cs" />
                 <Compile Include="CustomEqualityComparer.cs" />
                 <Compile Include="Diagnostics\ConsoleTraceListener.cs" />
                 <Compile Include="Diagnostics\EventText.cs" />
                 <Compile Include="Diagnostics\IEventTextFormatter.cs" />
                 <Compile Include="Diagnostics\LogChannel.cs" />
                 <Compile Include="Diagnostics\LogicalOperation.cs" />
                 <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="ICancellable.cs" />
                 <Compile Include="IProgressHandler.cs" />
                 <Compile Include="IProgressNotifier.cs" />
                 <Compile Include="IPromiseT.cs" />
                 <Compile Include="IPromise.cs" />
                 <Compile Include="IServiceLocator.cs" />
                 <Compile Include="ITaskController.cs" />
                 <Compile Include="JSON\JSONElementContext.cs" />
                 <Compile Include="JSON\JSONElementType.cs" />
                 <Compile Include="JSON\JSONGrammar.cs" />
                 <Compile Include="JSON\JSONParser.cs" />
                 <Compile Include="JSON\JSONScanner.cs" />
                 <Compile Include="JSON\JsonTokenType.cs" />
                 <Compile Include="JSON\JSONWriter.cs" />
                 <Compile Include="JSON\JSONXmlReader.cs" />
                 <Compile Include="JSON\JSONXmlReaderOptions.cs" />
                 <Compile Include="JSON\StringTranslator.cs" />
                 <Compile Include="Parallels\DispatchPool.cs" />
                 <Compile Include="Parallels\ArrayTraits.cs" />
                 <Compile Include="Parallels\MTQueue.cs" />
                 <Compile Include="Parallels\WorkerPool.cs" />
                 <Compile Include="Parsing\Alphabet.cs" />
                 <Compile Include="Parsing\AlphabetBase.cs" />
                 <Compile Include="Parsing\AltToken.cs" />
                 <Compile Include="Parsing\BinaryToken.cs" />
                 <Compile Include="Parsing\CatToken.cs" />
                 <Compile Include="Parsing\CDFADefinition.cs" />
                 <Compile Include="Parsing\DFABuilder.cs" />
                 <Compile Include="Parsing\DFADefinitionBase.cs" />
                 <Compile Include="Parsing\DFAStateDescriptor.cs" />
                 <Compile Include="Parsing\DFAutomaton.cs" />
                 <Compile Include="Parsing\EDFADefinition.cs" />
                 <Compile Include="Parsing\EmptyToken.cs" />
                 <Compile Include="Parsing\EndToken.cs" />
                 <Compile Include="Parsing\EnumAlphabet.cs" />
                 <Compile Include="Parsing\Grammar.cs" />
                 <Compile Include="Parsing\IAlphabet.cs" />
                 <Compile Include="Parsing\IDFADefinition.cs" />
                 <Compile Include="Parsing\IVisitor.cs" />
                 <Compile Include="Parsing\ParserException.cs" />
                 <Compile Include="Parsing\Scanner.cs" />
                 <Compile Include="Parsing\StarToken.cs" />
                 <Compile Include="Parsing\SymbolToken.cs" />
                 <Compile Include="Parsing\Token.cs" />
                 <Compile Include="SafePool.cs" />
                 <Compile Include="ServiceLocator.cs" />
                 <Compile Include="TaskController.cs" />
                 <Compile Include="ProgressInitEventArgs.cs" />
                 <Compile Include="Properties\AssemblyInfo.cs" />
                 <Compile Include="Promise.cs" />
                 <Compile Include="Parallels\AsyncPool.cs" />
                 <Compile Include="Safe.cs" />
                 <Compile Include="ValueEventArgs.cs" />
                 <Compile Include="PromiseExtensions.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 />
               <ProjectExtensions>
                 <MonoDevelop>
                   <Properties>
                     <Policies>
                       <CSharpFormattingPolicy IndentSwitchBody="True" NamespaceBraceStyle="EndOfLine" ClassBraceStyle="EndOfLine" InterfaceBraceStyle="EndOfLine" StructBraceStyle="EndOfLine" EnumBraceStyle="EndOfLine" MethodBraceStyle="EndOfLine" ConstructorBraceStyle="EndOfLine" DestructorBraceStyle="EndOfLine" BeforeMethodDeclarationParentheses="False" BeforeMethodCallParentheses="False" BeforeConstructorDeclarationParentheses="False" NewLineBeforeConstructorInitializerColon="NewLine" NewLineAfterConstructorInitializerColon="SameLine" BeforeIndexerDeclarationBracket="False" BeforeDelegateDeclarationParentheses="False" NewParentheses="False" SpacesBeforeBrackets="False" inheritsSet="Mono" inheritsScope="text/x-csharp" scope="text/x-csharp" />
                       <TextStylePolicy FileWidth="120" EolMarker="Unix" inheritsSet="VisualStudio" inheritsScope="text/plain" scope="text/x-csharp" />
                       <DotNetNamingPolicy DirectoryNamespaceAssociation="PrefixedHierarchical" ResourceNamePolicy="MSBuild" />
                       <TextStylePolicy FileWidth="120" TabsToSpaces="False" inheritsSet="VisualStudio" inheritsScope="text/plain" scope="application/xml" />
                       <XmlFormattingPolicy inheritsSet="Mono" inheritsScope="application/xml" scope="application/xml" />
                       <TextStylePolicy FileWidth="120" TabsToSpaces="False" inheritsSet="VisualStudio" inheritsScope="text/plain" scope="text/plain" />
                       <NameConventionPolicy>
                         <Rules>
                           <NamingRule Name="Namespaces" AffectedEntity="Namespace" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Types" AffectedEntity="Class, Struct, Enum, Delegate" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Interfaces" AffectedEntity="Interface" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredPrefixes>
                               <String>I</String>
                             </RequiredPrefixes>
                           </NamingRule>
                           <NamingRule Name="Attributes" AffectedEntity="CustomAttributes" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredSuffixes>
                               <String>Attribute</String>
                             </RequiredSuffixes>
                           </NamingRule>
                           <NamingRule Name="Event Arguments" AffectedEntity="CustomEventArgs" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredSuffixes>
                               <String>EventArgs</String>
                             </RequiredSuffixes>
                           </NamingRule>
                           <NamingRule Name="Exceptions" AffectedEntity="CustomExceptions" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredSuffixes>
                               <String>Exception</String>
                             </RequiredSuffixes>
                           </NamingRule>
                           <NamingRule Name="Methods" AffectedEntity="Methods" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Static Readonly Fields" AffectedEntity="ReadonlyField" VisibilityMask="Internal, Protected, Public" NamingStyle="CamelCase" IncludeInstanceMembers="False" IncludeStaticEntities="True" />
                           <NamingRule Name="Fields (Non Private)" AffectedEntity="Field" VisibilityMask="Internal, Public" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="ReadOnly Fields (Non Private)" AffectedEntity="ReadonlyField" VisibilityMask="Internal, Public" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="False" />
                           <NamingRule Name="Fields (Private)" AffectedEntity="Field, ReadonlyField" VisibilityMask="Private, Protected" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="False">
                             <RequiredPrefixes>
                               <String>m_</String>
                             </RequiredPrefixes>
                           </NamingRule>
                           <NamingRule Name="Static Fields (Private)" AffectedEntity="Field" VisibilityMask="Private" NamingStyle="CamelCase" IncludeInstanceMembers="False" IncludeStaticEntities="True">
                             <RequiredPrefixes>
                               <String>_</String>
                             </RequiredPrefixes>
                           </NamingRule>
                           <NamingRule Name="ReadOnly Fields (Private)" AffectedEntity="ReadonlyField" VisibilityMask="Private, Protected" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="False">
                             <RequiredPrefixes>
                               <String>m_</String>
                             </RequiredPrefixes>
                           </NamingRule>
                           <NamingRule Name="Constant Fields" AffectedEntity="ConstantField" VisibilityMask="VisibilityMask" NamingStyle="AllUpper" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Properties" AffectedEntity="Property" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Events" AffectedEntity="Event" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Enum Members" AffectedEntity="EnumMember" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Parameters" AffectedEntity="Parameter, LocalVariable" VisibilityMask="VisibilityMask" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Type Parameters" AffectedEntity="TypeParameter" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredPrefixes>
                               <String>T</String>
                             </RequiredPrefixes>
                           </NamingRule>
                         </Rules>
                       </NameConventionPolicy>
                     </Policies>
                   </Properties>
                 </MonoDevelop>
               </ProjectExtensions>
             </Project>

Implab/Parallels/ArrayTraits.cs +17 -9

             using Implab.Diagnostics;
             using System;
             using System.Collections.Generic;
             using System.Diagnostics;
             using System.Linq;
             using System.Text;
             using System.Threading;
             namespace Implab.Parallels {
                 public static class ArrayTraits {
                     class ArrayIterator<TSrc> : DispatchPool<int> {
                         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;
                         public ArrayIterator(TSrc[] source, Action<TSrc> action, int threads)
                             : base(threads) {
                             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;
                             m_action = action;
                             m_promise.Anyway(Dispose);
                             InitPool();
                         }
                         public Promise<int> Promise {
                             get {
                                 return m_promise;
                             }
                         }
                         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;
                         }
                         protected override void InvokeUnit(int unit) {
                             try {
                                 m_action(m_source[unit]);
                                 var pending = Interlocked.Decrement(ref m_pending);
                                 if (pending == 0)
                                     m_promise.Resolve(m_source.Length);
                             } catch (Exception e) {
                                 m_promise.Reject(e);
                             }
                         }
                     }
                     class ArrayMapper<TSrc, TDst>: DispatchPool<int> {
                         readonly Func<TSrc, TDst> m_transform;
                         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;
                         public ArrayMapper(TSrc[] source, Func<TSrc, TDst> transform, int threads)
                             : base(threads) {
                             Debug.Assert (source != null);
                             Debug.Assert( transform != null);
                             m_next = 0;
                             m_source = source;
                             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);
                             InitPool();
                         }
                         public Promise<TDst[]> Promise {
                             get {
                                 return m_promise;
                             }
                         }
                         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) {
                             try {
                                 m_dest[unit] = m_transform(m_source[unit]);
                                 var pending = Interlocked.Decrement(ref m_pending);
                                 if (pending == 0)
                                     m_promise.Resolve(m_dest);
                             } catch (Exception e) {
                                 m_promise.Reject(e);
                             }
                         }
                     }
                     public static IPromise<TDst[]> ParallelMap<TSrc, TDst> (this TSrc[] source, Func<TSrc,TDst> transform, int threads) {
                         if (source == null)
                             throw new ArgumentNullException("source");
                         if (transform == null)
                             throw new ArgumentNullException("transform");
                         var mapper = new ArrayMapper<TSrc, TDst>(source, transform, threads);
                         return mapper.Promise;
                     }
                     public static IPromise<int> ParallelForEach<TSrc>(this TSrc[] source, Action<TSrc> action, int threads) {
                         if (source == null)
                             throw new ArgumentNullException("source");
                         if (action == null)
                             throw new ArgumentNullException("action");
                         var iter = new ArrayIterator<TSrc>(source, action, threads);
                         return iter.Promise;
                     }
                     public static IPromise<TDst[]> ChainedMap<TSrc, TDst>(this TSrc[] source, ResultMapper<TSrc, IPromise<TDst>> transform, int threads) {
                         if (source == null)
                             throw new ArgumentNullException("source");
                         if (transform == null)
                             throw new ArgumentNullException("transform");
                         if (threads <= 0)
                             throw new ArgumentOutOfRangeException("Threads number must be greater then zero");
                         if (source.Length == 0)
                             return Promise<TDst[]>.ResultToPromise(new TDst[0]);
                         var promise = new Promise<TDst[]>();
                         var res = new TDst[source.Length];
                         var pending = source.Length;
                         object locker = new object();
                         int slots = threads;
                         // Analysis disable AccessToDisposedClosure
                         AsyncPool.InvokeNewThread(() => {
                             for (int i = 0; i < source.Length; i++) {
                                 if(promise.IsResolved)
                                     break; // stop processing in case of error or cancellation
                                 var idx = i;
                                 if (Interlocked.Decrement(ref slots) < 0) {
                                     lock(locker) {
                                         while(slots < 0)
                                             Monitor.Wait(locker);
                                     }
                                 }
                                 try {
                                     transform(source[i])
                                         .Anyway(() => {
                                             Interlocked.Increment(ref slots);
                                             lock (locker) {
                                                 Monitor.Pulse(locker);
                                             }
                                         })
                                         .Last(
                                             x => {
                                                 res[idx] = x;
                                                 var left = Interlocked.Decrement(ref pending);
                                                 if (left == 0)
                                                     promise.Resolve(res);
                                             },
                                             promise.Reject
                                         );
                                 } catch (Exception e) {
                                     promise.Reject(e);
                                 }
                             }
                             return 0;
                         });
                         return promise;
                     }
                 }
             }

Implab/Parallels/AsyncPool.cs +13 -7

             using Implab.Diagnostics;
             using System;
             using System.Threading;
             namespace Implab.Parallels {
             	/// <summary>
             	/// Класс для распаралеливания задач.
             	/// </summary>
             	/// <remarks>
             	/// Используя данный класс и лямда выражения можно распараллелить
             	/// вычисления, для этого используется концепция обещаний.
             	/// </remarks>
             	public static class AsyncPool {
             		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;
                         worker.Start();
                         return p;
                     }
                     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;
                         worker.Start();
                         return p;
                     }
             	}
             }

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 {
                     readonly int m_minThreadsLimit;
                     readonly int m_maxThreadsLimit;
                     readonly int m_releaseTimeout = 1000; // the timeout while the working thread will wait for the new tasks before exit
                     int m_threads = 0; // the current size of the pool
                     int m_maxRunningThreads = 0; // the meximum reached size of the pool
                     int m_exit = 0; // the pool is going to shutdown, all unused workers are released
                     readonly object m_signal = new object(); // used to pulse waiting threads
                     protected DispatchPool(int min, int max) {
                         if (min < 0)
                             throw new ArgumentOutOfRangeException("min");
                         if (max <= 0)
                             throw new ArgumentOutOfRangeException("max");
                         if (min > max)
                             min = max;
                         m_minThreadsLimit = min;
                         m_maxThreadsLimit = max;
                     }
                     protected DispatchPool(int threads)
                         : this(threads, threads) {
                     }
                     protected DispatchPool() {
                         int maxThreads, maxCP;
                         ThreadPool.GetMaxThreads(out maxThreads, out maxCP);
                         m_minThreadsLimit = 0;
                         m_maxThreadsLimit = maxThreads;
                     }
                     protected void InitPool() {
                         for (int i = 0; i < m_minThreadsLimit; i++)
                             StartWorker();
                     }
                     public int PoolSize {
                         get {
                             Thread.MemoryBarrier();
                             return m_threads;
                         }
                     }
                     public int MaxRunningThreads {
                         get {
                             Thread.MemoryBarrier();
                             return m_maxRunningThreads;
                         }
                     }
                     protected bool IsDisposed {
                         get {
                             Thread.MemoryBarrier();
                             return m_exit == 1;
                         }
                     }
                     protected abstract bool TryDequeue(out TUnit unit);
                     bool Dequeue(out TUnit unit, int timeout) {
                         int ts = Environment.TickCount;
                         if (TryDequeue(out unit))
                             return true;
                         lock (m_signal) {
                             while (!TryDequeue(out unit) && m_exit == 0)
                                 if(!Monitor.Wait(m_signal, Math.Max(0, ts + timeout - Environment.TickCount))) {
                                     // timeout
                                     return false;
                                 }
                             // queue item or terminate
                             Monitor.Pulse(m_signal);
                             if (m_exit == 1)
                                 return false;
                         }
                         return true;
                     }
                     protected void SignalThread() {
                         lock (m_signal) {
                             Monitor.Pulse(m_signal);
                         }
                     }
                     #region thread slots traits
                     bool AllocateThreadSlot() {
                         int current;
                         // use spins to allocate slot for the new thread
                         do {
                             current = m_threads;
                             if (current >= m_maxThreadsLimit || m_exit == 1)
                                 // no more slots left or the pool has been disposed
                                 return false;
                         } while (current != Interlocked.CompareExchange(ref m_threads, current + 1, current));
                         UpdateMaxThreads(current + 1);
                         return true;
                     }
                     bool AllocateThreadSlot(int desired) {
                         if (desired - 1 != Interlocked.CompareExchange(ref m_threads, desired, desired - 1))
                             return false;
                         UpdateMaxThreads(desired);
                         return true;
                     }
                     bool ReleaseThreadSlot(out bool last) {
                         last = false;
                         int current;
                         // use spins to release slot for the new thread
                         Thread.MemoryBarrier();
                         do {
                             current = m_threads;
                             if (current <= m_minThreadsLimit && m_exit == 0)
                                 // the thread is reserved
                                 return false;
                         } while (current != Interlocked.CompareExchange(ref m_threads, current - 1, current));
                         last = (current == 1);
                         return true;
                     }
                     void UpdateMaxThreads(int count) {
                         int max;
                         do {
                             max = m_maxRunningThreads;
                             if (max >= count)
                                 break;
                         } while(max != Interlocked.CompareExchange(ref m_maxRunningThreads, count, max));
                     }
                     #endregion
                     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);
                     protected virtual void Worker() {
                         TUnit unit;
                         bool last;
                         do {
                             while (Dequeue(out unit, m_releaseTimeout)) {
                                 InvokeUnit(unit);
                             }
                             if(!ReleaseThreadSlot(out last))
                                 continue;
                             // queue may be not empty
                             if (last && TryDequeue(out unit)) {
                                 InvokeUnit(unit);
                                 if (AllocateThreadSlot(1))
                                     continue;
                                 // we can safely exit since pool is alive
                             }
                             break;
                         } while(true);
                     }
                     protected virtual void Dispose(bool disposing) {
                         if (disposing) {
                             if (0 == Interlocked.CompareExchange(ref m_exit, 1, 0)) { // implies memory barrier
                                 // wake sleeping threads
                                 SignalThread();
                                 GC.SuppressFinalize(this);
                             }
                         }
                     }
                     public void Dispose() {
                         Dispose(true);
                     }
                     ~DispatchPool() {
                         Dispose(false);
                     }
                 }
             }

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;
             namespace Implab.Parallels {
                 public class WorkerPool : DispatchPool<Action> {
                     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();
                     }
                     public Promise<T> Invoke<T>(Func<T> task) {
                         if (task == null)
                             throw new ArgumentNullException("task");
                         if (IsDisposed)
                             throw new ObjectDisposedException(ToString());
                         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;
                     }
                     protected void EnqueueTask(Action unit) {
                         Debug.Assert(unit != null);
                         var len = Interlocked.Increment(ref m_queueLength);
                         m_queue.Enqueue(unit);
                         if (len > m_threshold * PoolSize) {
                             StartWorker();
                         }
                         SignalThread();
                     }
                     protected override bool TryDequeue(out Action unit) {
                         if (m_queue.TryDequeue(out unit)) {
                             Interlocked.Decrement(ref m_queueLength);
                             return true;
                         }
                         return false;
                     }
                     protected override void InvokeUnit(Action unit) {
                         unit();
                     }
                 }
             }

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