private static void Run(int n, int threadCount)
{
Dispatcher d = new Dispatcher(threadCount, "ccr pool");
DispatcherQueue dq = new DispatcherQueue("disp", d);
Port<int> p1 = new Port<int>(), p2 = new Port<int>();
EventWaitHandle done1 = new AutoResetEvent(false), done2 = new AutoResetEvent(false);
PingPonger pp1 = new PingPonger(done1, n, p2),
pp2 = new PingPonger(done2, n, p1);
Arbiter.Activate(dq, Arbiter.Interleave(
new TeardownReceiverGroup(),
new ExclusiveReceiverGroup(Arbiter.Receive(true, p1, pp1.Update)),
new ConcurrentReceiverGroup()));
Arbiter.Activate(dq, Arbiter.Interleave(
new TeardownReceiverGroup(),
new ExclusiveReceiverGroup(Arbiter.Receive(true, p2, pp2.Update)),
new ConcurrentReceiverGroup()));
p1.Post(0);
EventWaitHandle.WaitAll(new[] { done1, done2 });
dq.Dispose();
d.Dispose();
}
public void DispatchEventWithDispatcherQueueExceptionPort()
{
using (Dispatcher d = new Dispatcher ()) {
var dq = new DispatcherQueue ("foo", d);
var evt = new AutoResetEvent (false);
var port = new Port<Exception> ();
dq.UnhandledExceptionPort = port;
int portPost = 0;
int dispEx = 0;
d.UnhandledException += delegate { ++dispEx; };
var rec = Arbiter.Receive (true, port, (e) => { ++portPost; evt.Set(); });
rec.TaskQueue = dq;
rec.Execute ();
dq.Enqueue (Arbiter.FromHandler (() => { throw new Exception (); }));
Assert.IsTrue (evt.WaitOne (2000), "#1");
Assert.AreEqual (1, portPost, "#2");
Assert.AreEqual (0, dispEx, "#3");
dq.Enqueue (Arbiter.FromHandler (() => { throw new Exception (); }));
Assert.IsTrue (evt.WaitOne (2000), "#4");
Assert.AreEqual (2, portPost, "#5");
Assert.AreEqual (0, dispEx, "#6");
}
}
///////////////////////////////////////////////////////////////////
// if if{(join1) (expr0)}else{&element}
// if1 if{expr1 - &element0}elseif{&join1}else{&element}
// expr00 - if0 if{expr2 - element0}elseif{expr3 - &element0}elseif{[(expr5 - join)(expr4 - &join)] - element1}elseif{[(expr50 - join0)(expr40 - &join0)] - &element1}else{element}
// [(__use__3.snippet.snippet.noop - __use__3.snippet.snippet.expr - __use__3.snippet.snippet.join)] - __use__3.snippet.call - __use__3.snippet.call.iftype
// __use__50.snippet.snippet.noop - [(__use__50.snippet.snippet.expr0 - __use__50.snippet.snippet.join)(__use__50.snippet.snippet.expr - &__use__50.snippet.snippet.join)] - __use__50.snippet.call - __use__50.snippet.call.iftype
// __use__5.snippet0.snippet.noop - [(__use__5.snippet0.snippet.expr0 - __use__5.snippet0.snippet.join)(__use__5.snippet0.snippet.expr - &__use__5.snippet0.snippet.join)] - __use__5.snippet0.call - __use__5.snippet0.call.iftype
///////////////////////////////////////////////////////////////////
public OnSpeechRecognizerSpeechRecognizedHandler(DiagramService service, ccr.DispatcherQueue queue)
: base(service, queue)
{
// Activate merge handlers
Activate(ccr.Arbiter.Receive(true, _mergeAlpha, _mergeAlphaHandler));
Activate(ccr.Arbiter.Receive(true, _mergeBeta, _mergeBetaHandler));
Activate(ccr.Arbiter.Receive(true, _mergeGamma, _mergeGammaHandler));
RegisterAndActivateJoins();
}
public ThrottledQueue(string threadPoolName, string dispatcherQueueName,
PostMessageDelegate postMessage, int maxPoolItemReuse)
{
matchMaker = new MatchMaker(maxPoolItemReuse);
dispatcher = new Dispatcher(1, threadPoolName);
dispatcherQueue = new DispatcherQueue(dispatcherQueueName, dispatcher);
messagePort = new Port<QueueItem>();
Handler<QueueItem> handler = new Handler<QueueItem>(postMessage);
Arbiter.Activate(dispatcherQueue, Arbiter.Receive(true, messagePort, handler));
}
static void ParallelIntegration(dynamic step, dynamic Low, dynamic Up, ScriptScope scope)
{
// создание массива объектов для хранения параметров
InputData[] ClArr = new InputData[nc];
for (int i = 0; i < nc; i++)
ClArr[i] = new InputData();
//Далее, задаются исходные данные для каждого экземпляра
//вычислительного метода:
// заполняем массив параметров
dynamic Low_temp = Low;
for (int i = 0; i < nc; i++)
{
ClArr[i].start = Low_temp;
if (i + 1 == nc)
ClArr[i].stop = Up;
else
ClArr[i].stop = Low_temp + step;
Low_temp = Low_temp + step;
}
//Создаётся диспетчер с пулом из двух потоков:
Dispatcher d = new Dispatcher(nc, "Test Pool");
DispatcherQueue dq = new DispatcherQueue("Test Queue", d);
//Описывается порт, в который каждый экземпляр метода Int()
//отправляет сообщение после завершения вычислений:
Port<int> p = new Port<int>();
//Метод Arbiter.Activate помещает в очередь диспетчера две задачи(два
//экземпляра метода Mul):
System.Diagnostics.Stopwatch ssWatch = new System.Diagnostics.Stopwatch();
ssWatch.Start();
for (int i = 0; i < nc; i++)
Arbiter.Activate(dq, new Task<InputData, Port<int>, ScriptScope>(ClArr[i], p, scope, Int));
//Первый параметр метода Arbiter.Activate – очередь диспетчера,
//который будет управлять выполнением задачи, второй параметр –
//запускаемая задача.
//С помощью метода Arbiter.MultipleItemReceive запускается задача
//(приёмник), которая обрабатывает получение двух сообщений портом p:
Arbiter.Activate(dq, Arbiter.MultipleItemReceive(true, p, nc, delegate (int[] array)
{
Console.WriteLine("Вычисления завершены");
ssWatch.Stop();
Console.WriteLine("Полное время работы {0} мс", ssWatch.ElapsedMilliseconds.ToString());
Console.ReadKey(true);
Environment.Exit(0);
}));
Console.ReadKey(true);
Environment.Exit(0);
}
public ReloadDialog(ReloadConfig reloadConfig, IForwardLinkManagement transport, Node nexthopnode) {
this.m_NextHopNode = nexthopnode;
this.m_Transport = transport;
this.m_fDone = new Port<bool>();
this.m_DispatcherQueue = reloadConfig.DispatcherQueue;
this.m_ReloadConfig = reloadConfig;
m_Transport.ReloadFLMEventHandler += new ReloadFLMEvent(OVL_ReloadForwardLinkManagementEventHandler);
if(nexthopnode.IceCandidates == null)
throw new System.Exception(String.Format("ReloadDialog: no ice candidates for {0} ", nexthopnode.Id));
}
/// <summary>
/// Initializes new instance with specified path used for loading processing nodes, and number of worker threads
/// </summary>
/// <param name="path"></param>
public AlgoGrid(string path, int workerThreadCount)
{
m_dispatcher = new Dispatcher(workerThreadCount, "ThreadPool");
m_dispatcherQueue = new DispatcherQueue("Queue", m_dispatcher);
m_queue = new Port<IBaseItem>();
ITask task = Arbiter.Receive(true, m_queue, InnerHandle);
Arbiter.Activate(m_dispatcherQueue, task);
DirectoryCatalog catalog = new DirectoryCatalog(path);
CompositionContainer container = new CompositionContainer(catalog);
container.SatisfyImportsOnce(this);
}
static void Main(string[] args)
{
int i;
nc = 4;// количество ядер
n = 100000000;
Arr = new int[n];
int Result = 0;
Random r = new Random();
for (int j = 0; j < n; j++)
Arr[j] = r.Next(5);
System.Diagnostics.Stopwatch sWatch = new System.Diagnostics.Stopwatch();
sWatch.Start();
for (i = 9; i < n; i++)//последовательный алгоритм
{
Result = Result + Arr[i];
}
Console.WriteLine("Сумма:");
Console.WriteLine(Result);
sWatch.Stop();
Console.WriteLine("Последовательный алгоритм = {0} мс.", sWatch.ElapsedMilliseconds.ToString());
InputData[] ClArr = new InputData[nc];// создание массива объектов для хранения параметров
for (i = 0; i < nc; i++)
ClArr[i] = new InputData();
int step = (Int32)(n / nc); // делим количество элементов в массиве на nc частей
int c = -1;
for (i = 0; i < nc; i++)// заполняем массив параметров
{
ClArr[i].start = c + 1;
ClArr[i].stop = c + step;
ClArr[i].i = i;
c = c + step;
}
Dispatcher d = new Dispatcher(nc, "Test Pool");
DispatcherQueue dq = new DispatcherQueue("Test Queue", d);
Port<int> p = new Port<int>();
for (i = 0; i < nc; i++)
Arbiter.Activate(dq, new Task<InputData, Port<int>>(ClArr[i], p, Sum));
Arbiter.Activate(dq, Arbiter.MultipleItemReceive(true, p, nc, delegate(int[] array)
{ }));}}}
internal Node(RelayNodeDefinition nodeDefinition, NodeGroup ownerGroup, NodeCluster ownerCluster, ForwardingConfig forwardingConfig, DispatcherQueue inMessageQueue, DispatcherQueue outMessageQueue)
{
DetectedZone = 0;
NodeDefinition = nodeDefinition;
NodeGroup = ownerGroup;
NodeCluster = ownerCluster;
_messageCounts = new int[RelayMessage.NumberOfTypes];
_lastMessageTimes = new double[RelayMessage.NumberOfTypes];
_averageMessageTimes = new double[RelayMessage.NumberOfTypes];
if (EndPoint != null)
{
_transport = TransportFactory.CreateTransportForNode(nodeDefinition, ownerGroup.GroupDefinition, forwardingConfig.MessageChunkLength);
DetectedZone = NodeManager.Instance.GetZoneForAddress(EndPoint.Address);
if (forwardingConfig.MapNetwork)
{
HopsFromHere = HowManyHopsFromHere();
}
else
{
HopsFromHere = 0;
}
}
else
{
_transport = new NullTransport();
}
_inMessageQueue = inMessageQueue;
_outMessageQueue = outMessageQueue;
if (forwardingConfig != null)
{
_messageBurstLength = forwardingConfig.MessageBurstLength;
_messageBurstTimeout = forwardingConfig.MessageBurstTimeout;
_messageBurstTimeoutSpan = TimeSpan.FromMilliseconds(_messageBurstTimeout);
MessageErrorQueue = new MessageQueue(ownerGroup.GetQueueConfig());
_repostMessageLists = forwardingConfig.RepostMessageLists;
}
ActivateBurstReceive(1); //the burst length will be used after the first message is received
// async, no skipping of the error queue (duh)
Arbiter.Activate(_inMessageQueue,
Arbiter.Receive<List<SerializedRelayMessage>>(true, _inMessagesPort,
messages => DoHandleInMessages(messages, false)));
Arbiter.Activate(_outMessageQueue,
Arbiter.Receive<MessagesWithLock>(true, _outMessagesPort,
delegate(MessagesWithLock messages) { HandleOutMessages(messages.Messages); messages.Locker.Decrement(); }));
}
//Метод параллельной сортировки массива
static void parral_qsort(int[] a, int left, int right)
{
//Создаём диспетчеры
Dispatcher d = new Dispatcher(2, " Test Pool");
DispatcherQueue dq = new DispatcherQueue(" Test Queue", d);
//Описываем порт
Port<int> p = new Port<int>();
//Первый этап параллельной сортировки
//Параллельно сортируются две половины массива
InputData data = new InputData();
data.str = "Первая половина массива ";
data.array = a; data.start = 0; data.stop = right/2 + 1;
Arbiter.Activate(dq, new Task<InputData, Port<int>>(data, p, thread_fun));
Console.WriteLine("Первый этап");
Console.ReadKey();
data.str = "Вторая половина массива ";
data.array = a; data.start = right/2 + 1; data.stop = right;
Arbiter.Activate(dq, new Task<InputData, Port<int>>(data, p, thread_fun));
Console.ReadKey();
//Второй этап параллельной сортировки
//Сортируется центральная часть массива
Console.WriteLine();
Console.WriteLine("Второй этап");
Stopwatch sWatch = new Stopwatch();
sWatch.Start();
qsort(a,right/4,right/4+right/2 +1);
sWatch.Stop();
Console.WriteLine("Средняя часть массива Время работы: " + sWatch.ElapsedMilliseconds);
Console.ReadKey();
//Третий этап параллельной сортировки
//Параллельно сортируются две половины массива
data.str = "Первая половина массива ";
data.array = a; data.start = 0; data.stop = right / 2 + 1;
Arbiter.Activate(dq, new Task<InputData, Port<int>>(data, p, thread_fun));
Console.WriteLine("Первый этап");
Console.ReadKey();
data.str = "Вторая половина массива ";
data.array = a; data.start = right / 2 + 1; data.stop = right;
Arbiter.Activate(dq, new Task<InputData, Port<int>>(data, p, thread_fun));
Console.ReadKey();
return;
}
static void ParallelShellSort()
{
Dispatcher dispatcher = new Dispatcher(arraySize, "THREAD_POOL");
DispatcherQueue dsipQueue = new DispatcherQueue("Dispatcher", dispatcher);
Port<int> port = new Port<int>();
for (int i = 0; i < arraySize; ++i)
{
Data d = new Data();
d.row = i;
Arbiter.Activate(dsipQueue, new Task<Data, Port<int>>(d, port, Task));
}
return;
}
/// <summary>
/// Constructor for the class.
/// </summary>
/// <param name="portName">The port for communication</param>
/// <param name="queue">The robotics runtime DispatcherQueue</param>
public MotorControl(string portName, DispatcherQueue queue, GenericMotorService b)
{
myMotors = new SerialPort();
state = 0;
receive_ack = "";
dq = queue;
motorAckRecieve = new
PortSet<SendAck, Stop, Turn, SetSpeed, StopComplete, TurnComplete, BumperActivated>();
bumper = b;
//Initialize Serial Port Parameters
myMotors.PortName = portName;
myMotors.BaudRate = DEFAULT_BAUD_RATE;
myMotors.Parity = DEFAULT_PARITY;
myMotors.DataBits = DEFAULT_DATA_BITS;
myMotors.StopBits = DEFAULT_STOP_BITS;
myMotors.Handshake = DEFAULT_HANDSHAKE;
myMotors.ReadTimeout = DEFAULT_TIMEOUT;
myMotors.WriteTimeout = DEFAULT_TIMEOUT;
}
/// <summary>
/// Call to initialize the control and start threads. The main GUI
/// </summary>
public void Start()
{
queue = new DispatcherQueue("SimulatorDisplay", new Dispatcher());
throttledQueue = new DispatcherQueue("SimulatorDisplayThrottled", new Dispatcher(1, "SimulatorDisplayThrottled"), TaskExecutionPolicy.ConstrainQueueDepthDiscardTasks, 2);
// Start a thread that will wait one second, check for the SimulatorEngine,
// and start another check thread if it is not found, or trigger the
// SimulatorFound event if it is found.
ParameterizedThreadStart checker = new ParameterizedThreadStart(
delegate(object next)
{
//Console.WriteLine("Checking for simulator...");
if (checkSimulator() == false)
{
Thread.Sleep(TimeSpan.FromSeconds(1));
new Thread((ParameterizedThreadStart)next).Start(next);
}
});
new Thread(checker).Start(checker);
Arbiter.Activate(queue, Arbiter.Receive(false, sizeChangePort, SizeChangeHandler));
}
internal MessageTracer(short maxTypeId, TraceSettings traceSettings)
{
//dispatchers and dispatcher queues need unique names. it's unlikely that a single class could want more than one of these.
//blatantly stolen from mr custenborders logwrapper class
string name = ExtractClassName(new StackFrame(1).GetMethod());
_sampleTimer = new Timer(SampleTimerCallback);
ReloadConfig(maxTypeId, traceSettings);
_traceDispatcher = new Dispatcher(1, ThreadPriority.BelowNormal, true, name + "TraceDispatcher"); //using only 1 thread keeps us from needing any locking on the stream output
_traceMessageQueue = new DispatcherQueue(name + "DispatcherQueue", _traceDispatcher,
TaskExecutionPolicy.ConstrainQueueDepthDiscardTasks, 10000);
Arbiter.Activate(_traceMessageQueue,
Arbiter.Receive<RelayMessage>(true, _tracePort, DoWriteTraceInfo));
Arbiter.Activate(_traceMessageQueue,
Arbiter.Receive<IList<RelayMessage>>(true, _traceListPort, DoWriteTraceInfo));
Arbiter.Activate(_traceMessageQueue,
Arbiter.Receive<string>(true, _stringPort, DoWriteTraceInfo));
}
// markus end
public ReloadFLM(ReloadConfig reloadConfig)
{
m_ReloadConfig = reloadConfig;
m_DispatcherQueue = m_ReloadConfig.DispatcherQueue;
link.ReloadFLMEventHandler += new ReloadFLMEvent(link_ReloadFLMEventHandler);
}
private void onInitialized(object sender, EventArgs e)
{
taskQueue = new DispatcherQueue("DriveControl", new Dispatcher(1, "DriveControl"),
TaskExecutionPolicy.ConstrainQueueDepthDiscardTasks, 1);
Arbiter.Activate(taskQueue, Arbiter.Receive(true, drivePort, driveHandler));
UpdateJoystickAxes(new game.Axes());
}
public HandlerBase(DriveOperationsService service, ccr.DispatcherQueue queue)
: base(queue)
{
_service = service;
}
public void PortSetReceiveToBeUsedWithIterators()
{
iterPort = new PortSet (typeof (string), typeof (char), typeof (int));
iterEvent = new AutoResetEvent (false);
iterRes = 0;
using (Dispatcher d = new Dispatcher ()) {
var disp = new DispatcherQueue ("bla", d);
disp.Enqueue (new IterativeTask (this.SimpleTaskIterator));
for (int i = 0; i < 5; ++i)
iterPort.PostUnknownType ((i + 1) * 10);
Assert.IsTrue (iterEvent.WaitOne (2000), "#1");
Assert.AreEqual (150, iterRes, "#2");
}
}
static void ParallelMul()
{
InputData[] ClArr = new InputData[nc];
for (int i = 0; i < nc; i++)
ClArr[i] = new InputData();
int step = (Int32)(m / nc);
int c = -1;
for (int i = 0; i < nc; i++)
{
ClArr[i].start = c + 1;
ClArr[i].stop = c + step;
c = c + step;
}
Dispatcher d = new Dispatcher(nc, "Test Pool");
DispatcherQueue dq = new DispatcherQueue("Test Queue", d);
Port<int> p = new Port<int>();
for (int i = 0; i < nc; i++)
Arbiter.Activate(dq, new Task<InputData, Port<int>>(ClArr[i], p, Mul));
Arbiter.Activate(dq, Arbiter.MultipleItemReceive(true, p, nc, delegate (int[] array)
{
Console.WriteLine("Вычисления завершены");
Console.ReadKey(true);
Environment.Exit(0);
}));
}
internal void Step(ITask task, DispatcherQueue queue)
{
try {
if (iterator.MoveNext ()) {
task = iterator.Current;
task.LinkedIterator = this;
task.TaskQueue = queue;
task.Execute ();
}
} catch (Exception ex) {
this.iterator.Dispose ();
this.iterator = null;
Console.WriteLine (ex);
//TODO post it somewhere
}
}
static void Main(string[] args)
{
int i;
nc = 2;
n = 50000;
Console.WriteLine("\nМассив включает в себя {0} элементов\n", n);
a = new int[n];
mem = new int[n];
b = new int[nc];
Random r = new Random();
for (int j = 0; j < n; j++)
a[j] = r.Next(10000);
a.CopyTo(mem,0); //запомнили полученный массив
Console.WriteLine("Исходный массив успешно заполнен случайными значениями!\n");
arrDisplay();
System.Diagnostics.Stopwatch sWatch = new System.Diagnostics.Stopwatch();
Console.WriteLine("Начата последовательная сортировка массива...\n");
sWatch.Start();
for (i = 0; i <= n - 1; i++)
{
for (int j = i + 1; j < n; j++)
{
if (a[j] < a[i])
{
var temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
sWatch.Stop();
Console.WriteLine("Массив отсортирован последовательным алгоритмом!\n");
Console.WriteLine("Последовательный алгоритм = {0} мс.", sWatch.ElapsedMilliseconds.ToString());
arrDisplay(); //показали отсортированный массив
mem.CopyTo(a, 0); ; // восстановили массив со случайными числами
// создание массива объектов для хранения параметров
InputData[] tempArray = new InputData[nc];
i = 0;
while (i < nc)
{tempArray[i] = new InputData(); i++;}
// делим количество элементов в массиве на nc частей
int step = (Int32)(n / nc);
// заполняем массив параметров
int c = -1;
for (i = 0; i < nc; i++)
{
tempArray[i].start = c + 1;
tempArray[i].stop = c + step;
c = c + step;
}
Dispatcher d = new Dispatcher(nc, "Test Pool");
DispatcherQueue dq = new DispatcherQueue("Test Queue", d);
Port<int> p = new Port<int>();
for (i = 0; i < nc; i++)
Arbiter.Activate(dq, new Task<InputData, Port<int>>(tempArray[i], p, Mul));
Console.WriteLine("Начата параллельная сортировка массива...\n");
Arbiter.Activate(dq, Arbiter.MultipleItemReceive(true, p, nc, delegate(int[] array)
{
Console.WriteLine("Массив отсортирован параллельным алгоритмом!\n");
System.Diagnostics.Stopwatch newWatch = new System.Diagnostics.Stopwatch();
Console.WriteLine("Начата последовательная сортировка массива...\n");
newWatch.Start();
Array.Sort(a); //тот самый делегат в приемнике, с помощью которого шлейфуется результат параллельной сортировки пузырьком
newWatch.Stop();
Console.WriteLine("Окончательная сортировка средтвами C#: {0} мс.\n", newWatch.ElapsedMilliseconds.ToString());
arrDisplay();
Console.WriteLine("Вычисления завершены");
Console.ReadKey(true);
Environment.Exit(0);
}));
}
private void SetupOutMessagesOnRelayThreads(RelayNodeConfig newConfiguration)
{
//if it was off and is now on, or if it was on and the number of threads changed
bool setupNewOutMessages = (newConfiguration.OutMessagesOnRelayThreads && configuration.OutMessagesOnRelayThreads == false)
|| (configuration.OutMessagesOnRelayThreads && newConfiguration.OutMessagesOnRelayThreads
&& newConfiguration.NumberOfOutMessageThreads != configuration.NumberOfOutMessageThreads);
Dispatcher oldOutDispatcher = outDispatcher;
DispatcherQueue oldOutMessageQueue = outMessageQueue;
if (setupNewOutMessages)
{
try
{
const string outThreadsName = "DataRelayNodeOUT";
outMessagePort = new Port<RelayMessageAsyncResult>(); //atomic
outMessagesPort = new Port<RelayMessageListAsyncResult>(); //atomic
if (newConfiguration.NumberOfOutMessageThreads > 0)
{
outDispatcher = new Dispatcher(newConfiguration.NumberOfOutMessageThreads, ThreadPriority.Normal, true, outThreadsName);
}
else
{
outDispatcher = new Dispatcher { Name = outThreadsName };
}
outMessageQueue = new DispatcherQueue("DataRelayDispatcherQueueOUT", outDispatcher, TaskExecutionPolicy.ConstrainQueueDepthThrottleExecution, newConfiguration.MaximumOutMessageQueueDepth);
Arbiter.Activate(outMessageQueue,
Arbiter.ReceiveWithIterator(true, outMessagePort, HandleOutMessage));
Arbiter.Activate(outMessageQueue,
Arbiter.ReceiveWithIterator(true, outMessagesPort, HandleOutMessages));
}
catch (Exception e)
{
if(log.IsErrorEnabled)
log.ErrorFormat("Error setting up Out Message Threads on RelayNode: {0}", e);
throw;
}
}
if (newConfiguration.OutMessagesOnRelayThreads == false)
{
outMessagePort = null;
outMessagesPort = null;
if (oldOutDispatcher != null) oldOutDispatcher.Dispose();
if (oldOutMessageQueue != null) oldOutMessageQueue.Dispose();
}
}
///////////////////////////////////////////////////////////////////
// __use__.snippet0.snippet.noop - [(__use__.snippet0.snippet.expr1 - __use__.snippet0.snippet.join)(__use__.snippet0.snippet.expr0 - &__use__.snippet0.snippet.join)(__use__.snippet0.snippet.expr - &__use__.snippet0.snippet.join)] - __use__.snippet0.call - __use__.snippet0.call.iftype
// __use__0.snippet.call - __use__0.snippet.call.iftype
// [(snippet.snippet.noop - snippet.snippet.expr - snippet.snippet.join)] - snippet.element
///////////////////////////////////////////////////////////////////
public RotateMessageHandler(DriveOperationsService service, ccr.DispatcherQueue queue)
: base(service, queue)
{
}
internal void Register(DispatcherQueue queue)
{
lock (_lock) {
DispatcherQueue[] res = new DispatcherQueue [queues.Length + 1];
queues.CopyTo (res, 0);
res [queues.Length] = queue;
queues = res;
}
}
public HandlerBase(DiagramService service, ccr.DispatcherQueue queue)
: base(queue)
{
_service = service;
}
static void paral_qsort(int[] a, int left, int right)
{
int l = left;
int r = right;
int val = 0;
int mid = a[(l + r) / 2];
while (l <= r)
{
while ((a[l] < mid) && (l <= right))
{
l++;
}
while ((a[r] > mid) && (r >= left))
{
r--;
}
if (l <= r)
{
val = a[l];
a[l] = a[r];
a[r] = val;
l++;
r--;
}
}
InputData data1 = new InputData();
InputData data2 = new InputData();
if (r > left)
{
data1.str="Нить исполнения 1";
data1.array = a; data1.start = left; data1.stop = r;
//qsort(a, left, r);
}
if (l < right)
{
data2.str = "Нить исполнения 2";
data2.array = a; data2.start = l; data2.stop = right;
//qsort(a, l, right);
}
//Создаём диспетчеры
Dispatcher d = new Dispatcher(2, " Test Pool");
DispatcherQueue dq = new DispatcherQueue(" Test Queue", d);
//Описываем порт
Port<int> p = new Port<int>();
Arbiter.Activate(dq, new Task<InputData, Port<int>>(data1, p, thread_fun));
Arbiter.Activate(dq, new Task<InputData, Port<int>>(data2, p, thread_fun));
return;
}
internal void PostInternal(bool insertAtHead, PortElement <T> node)
{
bool flag = false;
ITask task = null;
DispatcherQueue dispatcherQueue = null;
lock (Store)
{
if (insertAtHead)
{
Store.ElementListAddFirst(node);
}
else
{
Store.ElementListAddLast(node);
}
if (Store.ReceiverCount == 0)
{
return;
}
int num = 1;
if (Store.ActiveReceiver == null)
{
num = Store.ReceiverCount;
}
ReceiverTask receiverTask = Store.ActiveReceiver;
int i = 0;
while (i < num)
{
if (num != 1)
{
receiverTask = Store.GetReceiverAtIndex(i);
}
task = null;
flag = receiverTask.Evaluate(node, ref task);
dispatcherQueue = receiverTask.TaskQueue;
if (flag)
{
Store.ElementListRemove(node);
if (receiverTask.State != ReceiverTaskState.Persistent)
{
Store.RemoveReceiver(receiverTask);
if (i > 1)
{
i--;
}
else
{
receiverTask = Store.ActiveReceiver;
}
num = Store.ReceiverCount;
break;
}
break;
}
else
{
if (task != null)
{
dispatcherQueue.Enqueue(task);
}
i++;
}
}
}
if (flag && task != null)
{
dispatcherQueue.Enqueue(task);
}
}
///////////////////////////////////////////////////////////////////
// __use__30.snippet0.snippet.noop - __use__30.snippet0.snippet.expr - __use__30.snippet0.snippet.join
// __use__30.snippet0.call - __use__30.snippet0.call.iftype
///////////////////////////////////////////////////////////////////
public OnWaitForDriveCompletionReplaceHandler(DiagramService service, ccr.DispatcherQueue queue)
: base(service, queue)
{
RegisterAndActivateJoins();
}
/// <summary>
/// Initialize the control and start the Python engine. This is not in the constructor or
/// OnLoaded because it breaks the VS designer. The main GUI window calls this.
/// </summary>
public void StartScripting()
{
pe = new PythonEngine();
pe.Sys.path.Add(Myro.Utilities.Params.BinPath);
//pe.Sys.path.Add(Myro.Utilities.Params.PythonPath);
//pe.Sys.path.Add("C:\\Users\\t-richr\\Myro-dev\\richard-dev-2\\Frontend\\Python");
//pe.Import("site");
pe.Sys.path.Add(System.IO.Path.GetDirectoryName(Assembly.GetEntryAssembly().Location));
var s = new AnonymousPipeServerStream(PipeDirection.In);
stdout = s;
stdoutpipe = new AnonymousPipeClientStream(PipeDirection.Out, s.ClientSafePipeHandle);
readThreadOut = new Thread(new ThreadStart(delegate() { readLoop(stdout, Colors.Black); }));
readThreadOut.Start();
var e = new AnonymousPipeServerStream(PipeDirection.In);
stderr = e;
stderrpipe = new AnonymousPipeClientStream(PipeDirection.Out, e.ClientSafePipeHandle);
readThreadErr = new Thread(new ThreadStart(delegate() { readLoop(stderr, Colors.Crimson); }));
readThreadErr.Start();
commandQueue = new Port<Command>();
commandDispatcherQueue = new DispatcherQueue("Python command queue", new Dispatcher(1, "Python command queue"));
Arbiter.Activate(commandDispatcherQueue, Arbiter.Receive(true, commandQueue, commandHandler));
pe.SetStandardOutput(stdoutpipe);
pe.SetStandardError(stderrpipe);
//Console.SetOut(new StreamWriter(stdoutpipe));
//Console.SetError(new StreamWriter(stderrpipe));
//Console.OpenStandardOutput();
//Console.OpenStandardError();
historyBlock.Document.PageWidth = historyBlock.ViewportWidth;
historyBlock.Document.Blocks.Clear();
paragraph = new Paragraph();
historyBlock.Document.Blocks.Add(paragraph);
historyBlock.IsEnabled = true;
}
internal void ReloadConfig(RelayNodeConfig newConfiguration)
{
if (newConfiguration != null)
{
if (log.IsInfoEnabled)
log.Info("Reloading configs.");
fatalFailureTimeout = newConfiguration.FatalShutdownTimeout < 0
? TimeSpan.FromMinutes(5)
: TimeSpan.FromSeconds(newConfiguration.FatalShutdownTimeout);
if (newConfiguration.GetMyNode() != null)
{
MyZone = newConfiguration.GetMyNode().Zone;
}
SetClusterAddresses(newConfiguration);
messageTracer.ReloadConfig(newConfiguration.TypeSettings.MaxTypeId, newConfiguration.TraceSettings);
messageTracer.Activated = newConfiguration.OutputTraceInfo;
//TODO: handle changes in component definition
components.ReloadConfig(newConfiguration, newConfiguration.IgnoredMessageTypes);
if (newConfiguration.TransportSettings != null)
{
if(newConfiguration.TransportSettings.ListenPort != portNumber)
{
log.InfoFormat("Changing Socket Transport Port to {0}",
newConfiguration.TransportSettings.ListenPort);
portNumber = newConfiguration.TransportSettings.ListenPort;
SocketServerAdapter.ChangePort(portNumber);
}
if(newConfiguration.TransportSettings.HttpListenPort != httpPortNumber)
{
if (httpPortNumber < 1 && newConfiguration.TransportSettings.HttpListenPort > 0) //there was no http server and now we want one
{
httpPortNumber = newConfiguration.TransportSettings.HttpListenPort;
StartHttpServer();
}
else if (newConfiguration.TransportSettings.HttpListenPort < 1 && httpPortNumber > 0) //shut off a running server
{
httpPortNumber = newConfiguration.TransportSettings.HttpListenPort;
StopHttpServer();
}
else //just change the port on an existing server
{
log.InfoFormat("Changing Http Transport Port to {0}",
newConfiguration.TransportSettings.HttpListenPort);
httpPortNumber = newConfiguration.TransportSettings.HttpListenPort;
_httpServer.ChangePort(httpPortNumber);
}
}
}
if (newConfiguration.NumberOfThreads != configuration.NumberOfThreads)
{
if(log.IsInfoEnabled)
log.InfoFormat("Changing number of relay node threads from {0} to {1}",
configuration.NumberOfThreads, newConfiguration.NumberOfThreads);
try
{
Dispatcher oldInDispatcher = inDispatcher;
Dispatcher newInDispatcher;
const string inThreadsName = "DataRelayNode";
if (newConfiguration.NumberOfThreads > 0)
{
newInDispatcher = new Dispatcher(newConfiguration.NumberOfThreads, ThreadPriority.Normal, true, inThreadsName);
}
else
{
newInDispatcher = new Dispatcher() { Name = inThreadsName };
}
DispatcherQueue newInQueue = new DispatcherQueue("DataRelayDispatcherQueue", newInDispatcher, TaskExecutionPolicy.ConstrainQueueDepthThrottleExecution, newConfiguration.MaximumMessageQueueDepth);
Interlocked.Exchange(ref inMessagePort, new Port<RelayMessage>());
Interlocked.Exchange(ref inMessageWithContextPort, new Port<RelayMessageWithContext>());
Interlocked.Exchange(ref inMessagesPort, new Port<IList<RelayMessage>>());
Arbiter.Activate(newInQueue,
Arbiter.Receive<RelayMessage>(true, inMessagePort, HandleInMessage));
Arbiter.Activate(newInQueue,
Arbiter.Receive<RelayMessageWithContext>(true, inMessageWithContextPort, HandleInMessage));
Arbiter.Activate(newInQueue,
Arbiter.Receive<IList<RelayMessage>>(true, inMessagesPort, HandleInMessages));
inMessageQueue = newInQueue;
inDispatcher = newInDispatcher;
oldInDispatcher.Dispose();
}
catch (Exception e)
{
if (log.IsErrorEnabled)
log.ErrorFormat("Error changing number of relay node threads: {0}", e);
}
}
else
{
//not rebuilding the queue, but reset its max queue depth anyway
inMessageQueue.MaximumQueueDepth = newConfiguration.MaximumMessageQueueDepth;
}
SetupOutMessagesOnRelayThreads(newConfiguration);
queuedTaskThreshold = (int)Math.Floor(0.9 * newConfiguration.MaximumMessageQueueDepth);
configuration = newConfiguration;
if (log.IsInfoEnabled)
log.Info("Done Reloading configs.");
}
else
{
if (log.IsErrorEnabled)
log.Error("Attempt to reload null config");
}
}
protected CcrServiceBase(DispatcherQueue dispatcherQueue) : this()
{
this.dispatcherQueue = dispatcherQueue;
}
/// <summary>
/// Initializes the <see cref="RelayNode"/> with the given <see cref="ComponentRunState"/>s,
/// must be called before calling <see cref="Start"/>
/// </summary>
/// <param name="componentRunStates"></param>
public void Initialize(ComponentRunState[] componentRunStates)
{
try
{
if (log.IsInfoEnabled)
{
if (componentRunStates == null)
{
log.Info("Initializing Relay Node.");
}
else
{
log.Info("Initialzing Relay Node with Component Run States.");
}
}
EnvironmentManager.EnvironmentChanged += EnvironmentChangedHandler;
GetConfig();
if (configuration == null) throw new ConfigurationErrorsException("config failed to load, is null");
SetClusterAddresses(configuration);
fatalFailureTimeout = configuration.FatalShutdownTimeout < 0
? TimeSpan.FromMinutes(5)
: TimeSpan.FromSeconds(configuration.FatalShutdownTimeout);
components = new RelayComponents(configuration);
if (configuration != null)
{
messageTracer = new MessageTracer(configuration.TypeSettings.MaxTypeId, configuration.TraceSettings);
messageTracer.Activated = configuration.OutputTraceInfo;
const string inThreadsName = "DataRelayNode";
if (configuration.NumberOfThreads > 0)
{
inDispatcher = new Dispatcher(configuration.NumberOfThreads, ThreadPriority.Normal, true, inThreadsName);
}
else
{
inDispatcher = new Dispatcher() { Name = inThreadsName } ;
}
const string outThreadsName = "DataRelayNodeOUT";
if (configuration.OutMessagesOnRelayThreads)
{
if (configuration.NumberOfOutMessageThreads > 0)
{
outDispatcher = new Dispatcher(configuration.NumberOfOutMessageThreads, ThreadPriority.Normal, true, outThreadsName);
}
else
{
outDispatcher = new Dispatcher { Name = outThreadsName };
}
outMessagePort = new Port<RelayMessageAsyncResult>();
outMessagesPort = new Port<RelayMessageListAsyncResult>();
outMessageQueue = new DispatcherQueue("DataRelayDispatcherQueueOUT", outDispatcher, TaskExecutionPolicy.ConstrainQueueDepthThrottleExecution, configuration.MaximumOutMessageQueueDepth);
Arbiter.Activate(outMessageQueue,
Arbiter.ReceiveWithIterator(true, outMessagePort, HandleOutMessage));
Arbiter.Activate(outMessageQueue,
Arbiter.ReceiveWithIterator(true, outMessagesPort, HandleOutMessages));
}
inMessageQueue = new DispatcherQueue("DataRelayDispatcherQueue", inDispatcher, TaskExecutionPolicy.ConstrainQueueDepthThrottleExecution, configuration.MaximumMessageQueueDepth);
queuedTaskThreshold = (int)Math.Floor(0.9 * configuration.MaximumMessageQueueDepth);
// setup RelayServicesClient before initalizing components
RelayServicesClient.Instance.RelayNodeServices = this;
Arbiter.Activate(inMessageQueue,
Arbiter.Receive<RelayMessage>(true, inMessagePort, HandleInMessage));
Arbiter.Activate(inMessageQueue,
Arbiter.Receive<RelayMessageWithContext>(true, inMessageWithContextPort, HandleInMessage));
Arbiter.Activate(inMessageQueue,
Arbiter.Receive<IList<RelayMessage>>(true, inMessagesPort, HandleInMessages));
//by having after the Arbiter.Activate it allows Initialize components to use
//IRelayNodeServices that require Message handling
components.Initialize(componentRunStates, configuration.IgnoredMessageTypes);
queuedMessageCounterTimer = new Timer(CountQueuedMessages, null, 5000, 5000);
}
}
catch (Exception ex)
{
if (log.IsErrorEnabled)
log.ErrorFormat("Exception initializing relay node: {0}", ex);
throw; //should bring server down
}
}
static void Main(string[] args)
{
int i;
nc = 2;
n = 100000000;
a = new int[n];
b = new int[nc];
Random r = new Random();
for (int j = 0; j < n; j++)
a[j] = r.Next(100);
System.Diagnostics.Stopwatch sWatch = new System.Diagnostics.Stopwatch();
sWatch.Start();
for (i = 0; i <= n; i++)
{
for (int j = i; i <= n; i++)
{
if (a[j] > a[j + 1])
{
int e = a[j]; //change for elements
a[j] = a[j + 1];
a[j + 1] = e;
}
}
}
sWatch.Stop();
Console.WriteLine("Последовательный алгоритм = {0} мс.", sWatch.ElapsedMilliseconds.ToString());
// создание массива объектов для хранения параметров
InputData[] ClArr = new InputData[nc];
for (i = 0; i < nc; i++)
ClArr[i] = new InputData();
// делим количество элементов в массиве на nc частей
int step = (Int32)(n / nc);
// заполняем массив параметров
int c = -1;
for (i = 0; i < nc; i++)
{
ClArr[i].start = c + 1;
ClArr[i].stop = c + step;
ClArr[i].i = i;
c = c + step;
}
Dispatcher d = new Dispatcher(nc, "Test Pool");
DispatcherQueue dq = new DispatcherQueue("Test Queue", d);
Port<int> p = new Port<int>();
for (i = 0; i < nc; i++)
Arbiter.Activate(dq, new Task<InputData, Port<int>>(ClArr[i], p, Mul));
Arbiter.Activate(dq, Arbiter.MultipleItemReceive(true, p, nc, delegate(int[] array)
{ }));
}
public void ParallelShell()
{
processes = new InputData[nc];
Console.WriteLine("Параллельная сортировка");
//Console.WriteLine("Массив до сортировки:");
//Display(0, partSize * nc);
int c = -1;
for (int i = 0; i < nc; i++)
{
processes[i] = new InputData();
processes[i].start = c + 1;
processes[i].stop = c + partSize - 1;
c += partSize - 1;
}
dq = new DispatcherQueue("Queue", d);
p1 = new Port<int>();
for (int i = 0; i < nc; i++)
{
Arbiter.Activate(dq, new Task<InputData, Port<int>>(processes[i], p1, FirstPhase));
}
// Все потоки завершили работу, финальная сортировка
Arbiter.Activate(dq, Arbiter.MultipleItemReceive(true, p1, nc, delegate(int[] array)
{
Stopwatch sw = new Stopwatch();
Console.WriteLine("Финальная сортировка");
sw.Start();
//int inner, temp;
//for (int i = 0; i < partSize * nc; i++)
//{
// temp = dataArray[i];
// inner = i;
// while (inner > 0 && dataArray[inner - 1] >= temp)
// {
// dataArray[inner] = dataArray[inner - 1];
// inner--;
// }
// dataArray[inner] = temp;
//}
Array.Sort(dataArray);
sw.Stop();
Console.WriteLine("Финальная сортировка заняла {0} мс", sw.ElapsedMilliseconds.ToString());
//Console.WriteLine("Результат:");
//Display(0, nc * partSize);
}
));
}
public static void ExecuteNow(DispatcherQueue dispatcherQueue, ITask task)
{
task.TaskQueue = dispatcherQueue;
TaskExecutionWorker.ExecuteInCurrentThreadContext(task);
}
///////////////////////////////////////////////////////////////////
// program.activity.Start+start
// snippet.element
// __use__.snippet0.call - __use__.snippet0.call.iftype
// [(__use__0.snippet0.snippet.noop - __use__0.snippet0.snippet.expr - __use__0.snippet0.snippet.join)] - __use__0.snippet0.call - __use__0.snippet0.call.iftype
///////////////////////////////////////////////////////////////////
public StartHandler(DiagramService service, ccr.DispatcherQueue queue)
: base(service, queue)
{
}
internal ITask Dequeue(ref int start, out DispatcherQueue queue)
{
DispatcherQueue[] queues = this.queues;
ITask task = null;
int qlen = queues.Length;
while (active) {
for (int i = 0; i < qlen; ++i) {
int idx = (i + start) % qlen;
if (queues [idx].TryDequeue (out task)) {
queue = queues [idx];
start = (idx + 1) % qlen;
Interlocked.Decrement (ref pendingTasks);
return task;
}
}
lock (_lock) {
for (int i = 0; i < qlen; ++i) {
int idx = (i + start) % qlen;
if (queues [idx].TryDequeue (out task)) {
queue = queues [idx];
start = (idx + 1) % qlen;
Interlocked.Decrement (ref pendingTasks);
return task;
}
}
Interlocked.Increment (ref pendingWorkers);
Monitor.Wait (_lock);
Interlocked.Decrement (ref pendingWorkers);
}
}
queue = null;
return null;
}
/// <summary>
/// Start conversation with the SickLRF device.
/// </summary>
IEnumerator<ITask> StartLRF(int timeout, int comPort)
{
Tracer.Trace("SickLRF::StartLRF() comPort=" + comPort);
if (timeout > 0)
{
//
// caller asked us to wait <timeout> milliseconds until we start.
//
yield return Arbiter.Receive(false, TimeoutPort(timeout),
delegate(DateTime dt)
{
LogInfo("Done Waiting");
}
);
}
if (_queue == null)
{
//
// The internal services run on their own dispatcher, we need to create that (once)
//
AllocateExecutionResource allocExecRes = new AllocateExecutionResource(0, "SickLRF");
ResourceManagerPort.Post(allocExecRes);
yield return Arbiter.Choice(
allocExecRes.Result,
delegate(ExecutionAllocationResult result)
{
_queue = result.TaskQueue;
},
delegate(Exception e)
{
LogError(e);
}
);
}
string comName;
if (comPort <= 0)
{
//
// We default to COM4, because
// a) that was our previous behavior and
// b) the hardware that we have uses COM4
//
comName = "COM4";
}
else
{
comName = "COM" + comPort;
}
_link = new CommLink(_queue ?? TaskQueue, comName, _internalPort);
_link.Parent = ServiceInfo.Service;
_link.Console = ConsoleOutputPort;
FlushPortSet(_internalPort);
yield return(
Arbiter.Choice(
_link.Open(),
delegate(SuccessResult success)
{
LogInfo("Opened link to LRF");
},
delegate(Exception exception)
{
LogError(exception);
}
)
);
}
internal void Notify(DispatcherQueue queue)
{
int curPending = Interlocked.Increment (ref pendingTasks);
if (workers.Count == 0 || (curPending > 0 && workers.Count < maxThreads)) {
SpawnWorker ();
return;
}
lock (_lock) {
if (Thread.VolatileRead (ref pendingWorkers) != 0)
Monitor.Pulse (_lock);
}
}
