private static void InternalResponseHandlerTestSingleThread(SessionBase session) { NetTcpBinding binding = Utils.CreateNetTcpBinding(); byte[] task_data = new byte[input_data_size]; (new Random()).NextBytes(task_data); data.SendStart = DateTime.Now; var responseHandlers = new List <ResponseHandlerBase>(); for (int i = 0; i < batchCount; i++) { int msg_count = req_count / batchCount; if (i == batchCount - 1) { msg_count += req_count % batchCount; } string clientId = Environment.MachineName + "-" + i.ToString() + "-" + Process.GetCurrentProcess().Id.ToString(); var client = new BrokerClient <IService1>(clientId, session, binding); ResponseHandlerBase handler; handler = new ComputeWithInputDataResponseHandler(client, clientId, common_data_size, retryRequestAndIgnoreRetryOperationError); client.SetResponseHandler <ComputeWithInputDataResponse>(((ComputeWithInputDataResponseHandler)handler).ResponseHandler <ComputeWithInputDataResponse>); responseHandlers.Add(handler); ClientSendRequest(client, clientId, msg_count, task_data); } //Log("The max interval of SendRequest opertaion is {0} milliseconds.", sendInterval); data.SendEnd = DateTime.Now; foreach (ResponseHandlerBase handler in responseHandlers) { handler.WaitOne(); data.ResultCollection.AddRange(handler.results); data.FaultCount += handler.faultCalls; try { handler.client.Close(durable, 10 * 60 * 1000); } catch (Exception e) { Log("Purge client {0} failed: {1}", handler.clientId.ToString(), e.ToString()); } } data.RetrieveEnd = DateTime.Now; }
private static void CustomizedResponseHandlerTest(SessionBase session) { NetTcpBinding binding = Utils.CreateNetTcpBinding(); byte[] task_data = new byte[input_data_size]; (new Random()).NextBytes(task_data); object mylock = default(object); for (int i = 0; i < req_count; i++) { string clientId = Guid.NewGuid().ToString(); BrokerClient <IService1> client = new BrokerClient <IService1>(clientId, session, binding); ResponseHandlerBase handler; handler = new ComputeWithInputDataResponseHandler(client, clientId, common_data_size, retryRequestAndIgnoreRetryOperationError); // Measure the set response handler time Stopwatch watch = Stopwatch.StartNew(); client.SetResponseHandler <ComputeWithInputDataResponse>( response => { lock (mylock) { response.Dispose(); client.Close(); } } ); watch.Stop(); Log("Elapsed time for SetResponseHandler is {0} milliseconds", watch.ElapsedMilliseconds); // Send requests client.SendRequest <ComputeWithInputDataRequest>(new ComputeWithInputDataRequest(millisec_for_each_req, task_data, commonData_dataClientId, output_data_size, DateTime.Now)); data.ReqEom = DateTime.Now; client.EndRequests(10 * 60 * 1000); data.ReqEomDone = DateTime.Now; // Send every 0-4 sec //Thread.Sleep((new Random()).Next(4000)); } }
static void Main(string[] args) { if (args.Length >= 1) { name = args[0]; } if (args.Length >= 2) { headnode = args[1]; } if (args.Length >= 3) { messageCount = int.Parse(args[2]); } Console.WriteLine("Creating session..."); using (Session session = Session.CreateSession(new SessionStartInfo(headnode, "HelloWorld"))) { using (BrokerClient<IHelloWorld> brokerClient = new BrokerClient<IHelloWorld>(session)) { brokerClient.SetResponseHandler<SayHelloResponse>(ResponseHandler); Console.WriteLine("Sending requests..."); for (int i = 0; i < messageCount; i++) { brokerClient.SendRequest(new SayHelloRequest(name)); } Console.WriteLine("Committing requests..."); brokerClient.EndRequests(); Console.WriteLine("Waiting for responses..."); Console.ReadLine(); } } }
private static void InternalResponseHandlerTestMultiThreads(SessionBase session) { NetTcpBinding binding = Utils.CreateNetTcpBinding(); byte[] task_data = new byte[input_data_size]; (new Random()).NextBytes(task_data); AutoResetEvent allClientSendEvt = new AutoResetEvent(false); AutoResetEvent allClientDoneEvt = new AutoResetEvent(false); int clientSendCounting = batchCount; int clientDoneCounting = batchCount; data.SendStart = DateTime.Now; for (int i = 0; i < batchCount; i++) { int msg_count = req_count / batchCount; if (i == batchCount - 1) { msg_count += req_count % batchCount; } string clientId = Environment.MachineName + "-" + i.ToString() + "-" + Process.GetCurrentProcess().Id.ToString(); Thread t = new Thread(new ThreadStart(() => { AutoResetEvent batchDone = new AutoResetEvent(false); using (var client = new BrokerClient <IService1>(clientId, session, binding)) { ResponseHandlerBase handler; handler = new ComputeWithInputDataResponseHandler(client, clientId, common_data_size, retryRequestAndIgnoreRetryOperationError); client.SetResponseHandler <ComputeWithInputDataResponse>(((ComputeWithInputDataResponseHandler)handler).ResponseHandler <ComputeWithInputDataResponse>); ClientSendRequest(client, clientId, msg_count, task_data); if (Interlocked.Decrement(ref clientSendCounting) <= 0) { allClientSendEvt.Set(); } handler.WaitOne(); Log("Client {0}: All requests returned.", clientId); lock (lockobject) { data.ResultCollection.AddRange(handler.results); data.FaultCount = handler.faultCalls; } try { client.Close(durable, 10 * 60 * 1000); } catch (Exception e) { Log("Purge client {0} failed: {1}", clientId, e.ToString()); } if (Interlocked.Decrement(ref clientDoneCounting) <= 0) { allClientDoneEvt.Set(); } } })); t.Start(); } allClientSendEvt.WaitOne(); data.SendEnd = DateTime.Now; allClientDoneEvt.WaitOne(); data.RetrieveEnd = DateTime.Now; }
static void Main(string[] args) { CmdParser parser = new CmdParser(args); Config config = new Config(parser); if (config.HelpInfo) { config.PrintHelp(); return; } if (config.Verbose) { config.PrintUsedParams(parser); } if (config.PrintUnusedParams(parser)) { config.PrintHelp(); return; } // TODO: SessionStartInfoFactory SessionStartInfo info = null; if (config.IsNoSession) { // Start session without session manager if (config.InprocessBroker) { info = new SessionStartInfo(config.ServiceName, config.RegPath, null, config.TargetList?.ToArray()); info.UseInprocessBroker = true; info.IsNoSession = true; } else { info = new SessionStartInfo(config.HeadNode, config.ServiceName, config.RegPath, null, config.TargetList?.ToArray()); info.UseInprocessBroker = false; info.IsNoSession = true; } } else { info = new SessionStartInfo(config.HeadNode, config.ServiceName); info.IsNoSession = false; info.UseInprocessBroker = config.InprocessBroker; } if (!string.IsNullOrEmpty(config.Username)) { info.Username = config.Username; } if (!string.IsNullOrEmpty(config.Password)) { info.Password = config.Password; } if (!string.IsNullOrEmpty(config.JobName)) { info.ServiceJobName = config.JobName; } if (!string.IsNullOrEmpty(config.AzureStorageConnectionString)) { info.AzureStorageConnectionString = config.AzureStorageConnectionString; info.BrokerLauncherStorageConnectionString = config.AzureStorageConnectionString; } switch (config.ResourceType.ToLowerInvariant()) { case "core": info.SessionResourceUnitType = SessionUnitType.Core; break; case "node": info.SessionResourceUnitType = SessionUnitType.Node; break; case "socket": info.SessionResourceUnitType = SessionUnitType.Socket; break; case "gpu": info.SessionResourceUnitType = SessionUnitType.Gpu; break; default: break; } if (config.MaxResource > 0) { info.MaximumUnits = config.MaxResource; } if (config.MinResource > 0) { info.MinimumUnits = config.MinResource; } switch (config.TransportScheme.ToLowerInvariant()) { case "nettcp": info.TransportScheme = TransportScheme.NetTcp; break; case "http": info.TransportScheme = TransportScheme.Http; break; case "nethttp": info.TransportScheme = TransportScheme.NetHttp; break; case "custom": info.TransportScheme = TransportScheme.Custom; break; case "azstorage": info.TransportScheme = TransportScheme.AzureStorage; break; default: break; } info.JobTemplate = config.JobTemplate; info.SessionPriority = config.Priority; info.NodeGroupList = new List <string>(config.NodeGroups.Split(new char[] { ',' })); info.RequestedNodesList = new List <string>(config.Nodes.Split(new char[] { ',' })); info.Secure = !config.Insecure && !config.IsNoSession; info.UseAzureQueue = config.AzureQueue; info.ShareSession = config.ShareSession; info.UseSessionPool = config.SessionPool; info.ParentJobIds = StringToIntList(config.ParentIds); info.ServiceHostIdleTimeout = config.ServiceIdleSec == -1 ? config.ServiceIdleSec : config.ServiceIdleSec * 1000; info.ServiceHangTimeout = config.ServiceHangSec == -1 ? config.ServiceHangSec : config.ServiceHangSec * 1000; info.UseWindowsClientCredential = config.UseWCC; info.UseAad = config.UseAad; if (config.Runtime > 0) { info.Runtime = config.Runtime; } if (!string.IsNullOrEmpty(config.Environment)) { foreach (string keyValue in config.Environment.Split(new char[] { ',' })) { string[] p = keyValue.Split(new char[] { '=' }); if (p.Length == 2) { info.Environments.Add(p[0], p[1]); } } } Stopwatch watch = new Stopwatch(); int timeoutMilliSec = config.MsgTimeoutSec * 1000; Dictionary <Guid, Dictionary <Guid, TaskRecord> > brokerClientTaskTimeRecords = new Dictionary <Guid, Dictionary <Guid, TaskRecord> >(config.BrokerClient); Dictionary <Guid, DateTime> brokerSendRequestStartTime = new Dictionary <Guid, DateTime>(config.BrokerClient); Dictionary <Guid, DateTime> brokerSendRequestEndTime = new Dictionary <Guid, DateTime>(config.BrokerClient); Dictionary <Guid, DateTime> brokerGetResponseStartTime = new Dictionary <Guid, DateTime>(config.BrokerClient); Dictionary <Guid, DateTime> brokerGetResponseEndTime = new Dictionary <Guid, DateTime>(config.BrokerClient); Random rTimeMS = new Random(); Random rSizeKB = new Random(); int maxTimeMS = 0; int minTimeMS = 0; int maxSizeKB = 0; int minSizeKB = 0; if (!string.IsNullOrEmpty(config.TimeMSRandom)) { string[] values = config.TimeMSRandom.Split(new char[] { '_' }, StringSplitOptions.RemoveEmptyEntries); if (values.Length == 2) { int.TryParse(values[0], out minTimeMS); int.TryParse(values[1], out maxTimeMS); } } if (!string.IsNullOrEmpty(config.SizeKBRandom)) { string[] values = config.SizeKBRandom.Split(new char[] { '_' }, StringSplitOptions.RemoveEmptyEntries); if (values.Length == 2) { int.TryParse(values[0], out minSizeKB); int.TryParse(values[1], out maxSizeKB); } } for (int c = 0; c < config.BrokerClient; c++) { Dictionary <Guid, TaskRecord> taskTimeReconds = new Dictionary <Guid, TaskRecord>(config.NumberOfRequest); for (int i = 0; i < config.NumberOfRequest; i++) { Guid g = Guid.NewGuid(); TaskRecord t = new TaskRecord() { RequestTime = DateTime.MinValue, ResponseTime = DateTime.MinValue }; if (maxTimeMS > 0) { t.CallDurationMS = rTimeMS.Next(minTimeMS, maxTimeMS); } else { t.CallDurationMS = config.CallDurationMS; } if (maxSizeKB > 0) { t.MessageSizeByte = rSizeKB.Next(minSizeKB, maxSizeKB) * 1024; } else { t.MessageSizeByte = config.MessageSizeByte; } taskTimeReconds.Add(g, t); } Guid clientGuid = Guid.NewGuid(); brokerClientTaskTimeRecords.Add(clientGuid, taskTimeReconds); brokerSendRequestStartTime.Add(clientGuid, DateTime.MinValue); brokerSendRequestEndTime.Add(clientGuid, DateTime.MinValue); brokerGetResponseStartTime.Add(clientGuid, DateTime.MinValue); brokerGetResponseEndTime.Add(clientGuid, DateTime.MinValue); } // Create an interactive or durable session Logger.Info("Creating a session for CcpEchoSvc service..."); SessionBase session = null; try { watch.Start(); if (config.Durable) { session = DurableSession.CreateSession(info); } else { session = Session.CreateSession(info); } watch.Stop(); Logger.Info("{0, -35} : {1}", "Session ID", session.Id); Logger.Info("{0, -35} : {1:F3} sec", "Session creation time", watch.Elapsed.TotalSeconds); //session warm up time if (config.WarmupTimeSec > 0) { Logger.Info("Session warming up in {0} seconds...", config.WarmupTimeSec); Thread.Sleep(config.WarmupTimeSec * 1000); } int clientNumber = config.BrokerClient; int clientCounter = 0; AutoResetEvent allDone = new AutoResetEvent(false); foreach (Guid g in brokerClientTaskTimeRecords.Keys) { ThreadPool.QueueUserWorkItem((o) => { Guid brokerClientGuid = (Guid)o; AutoResetEvent done = new AutoResetEvent(false); int count = 0; int clientC = Interlocked.Increment(ref clientCounter); Stopwatch watchT = new Stopwatch(); try { // Create a BrokerClient proxy using (BrokerClient <IEchoSvc> client = new BrokerClient <IEchoSvc>(brokerClientGuid.ToString(), session)) { if (config.AsyncResponseHandler) { //set getresponse handler Logger.Info("Setting response handler ({0}/{1}) to receive responses async.", clientC, config.BrokerClient); client.SetResponseHandler <GenerateLoadResponse>((item) => { try { Guid gg = item.RequestMessageId; StatisticInfo si = item.Result.GenerateLoadResult; if (config.Verbose) { Logger.Info("Response async received ({0}/{1}) {2} : {3}. StartTime-EndTime : {4:HH:mm:ss.fff}-{5:HH:mm:ss.fff}", clientC, config.BrokerClient, item.GetUserData <int>(), gg, si.StartTime, si.EndTime); } brokerClientTaskTimeRecords[brokerClientGuid][gg].ResponseTime = DateTime.Now; } catch (FaultException ex) { Logger.Warning("FaultException while getting responses in callback. \n{0}", ex.ToString()); } catch (RetryOperationException ex) { Logger.Warning("RetryOperationException while getting responses in callback. \n{0}", ex.ToString()); } catch (SessionException ex) { Logger.Warning("SessionException while getting responses in callback. \n{0}", ex.ToString()); } catch (Exception ex) { Logger.Warning("Exception while getting responses in callback. \n{0}", ex.ToString()); } if (Interlocked.Increment(ref count) == config.NumberOfRequest) { done.Set(); } }); } Logger.Info("Sending {0} requests for broker client ({1}/{2})...", config.NumberOfRequest, clientC, config.BrokerClient); brokerSendRequestStartTime[brokerClientGuid] = DateTime.Now; watchT.Restart(); int i = 0; foreach (Guid requestGuid in brokerClientTaskTimeRecords[brokerClientGuid].Keys) { i++; GenerateLoadRequest request = new GenerateLoadRequest(brokerClientTaskTimeRecords[brokerClientGuid][requestGuid].CallDurationMS, new byte[brokerClientTaskTimeRecords[brokerClientGuid][requestGuid].MessageSizeByte], null); client.SendRequest <GenerateLoadRequest>(request, i, timeoutMilliSec, new System.Xml.UniqueId(requestGuid)); if (config.Verbose) { Logger.Info("Sent request {0} for ({1}/{2}) : {3} : timeMS - {4} sizeByte - {5}", i, clientC, config.BrokerClient, requestGuid, brokerClientTaskTimeRecords[brokerClientGuid][requestGuid].CallDurationMS, brokerClientTaskTimeRecords[brokerClientGuid][requestGuid].MessageSizeByte); } brokerClientTaskTimeRecords[brokerClientGuid][requestGuid].RequestTime = DateTime.Now; if (config.Flush > 0 && i % config.Flush == 0) { client.Flush(timeoutMilliSec); } } // Flush the message client.EndRequests(timeoutMilliSec); watchT.Stop(); brokerSendRequestEndTime[brokerClientGuid] = DateTime.Now; double requestElapsedSeconds = watchT.Elapsed.TotalSeconds; double requestThroughput = config.NumberOfRequest / requestElapsedSeconds; Logger.Info("{0, -35} : {1:F3} sec", string.Format("Requests sent time ({0}/{1})", clientC, config.BrokerClient), requestElapsedSeconds); Logger.Info("{0, -35} : {1:F2} /sec", string.Format("Requests throughput ({0}/{1})", clientC, config.BrokerClient), requestThroughput); if (!config.AsyncResponseHandler) { Logger.Info("Retrieving responses for broker client ({0}/{1})...", clientC, config.BrokerClient); try { brokerGetResponseStartTime[brokerClientGuid] = DateTime.Now; watchT.Restart(); int responseNumber = 0; foreach (BrokerResponse <GenerateLoadResponse> response in client.GetResponses <GenerateLoadResponse>(timeoutMilliSec)) { try { Guid gg = response.RequestMessageId; StatisticInfo si = response.Result.GenerateLoadResult; if (config.Verbose) { Logger.Info("Response received ({0}/{1}) {2} : {3}. StartTime-EndTime : {4:HH:mm:ss.fff}-{5:HH:mm:ss.fff}", clientC, config.BrokerClient, response.GetUserData <int>(), gg, si.StartTime, si.EndTime); } else { Logger.Progress(string.Empty, responseNumber, config.NumberOfRequest); } brokerClientTaskTimeRecords[brokerClientGuid][gg].ResponseTime = DateTime.Now; } catch (FaultException e) { // Application exceptions Logger.Warning("FaultException when getting responses. \n{0}", e.ToString()); } catch (RetryOperationException e) { // RetryOperationExceptions may or may not be recoverable Logger.Warning("RetryOperationException when getting responses. \n{0}", e.ToString()); } catch (SessionException e) { // Exception Logger.Warning("SessionException when getting responses. \n{0}", e.ToString()); } catch (Exception e) { // Exception Logger.Warning("Exception when getting responses. \n{0}", e.ToString()); } finally { responseNumber++; } } watchT.Stop(); brokerGetResponseEndTime[brokerClientGuid] = DateTime.Now; double elapsedTimeSec = watchT.Elapsed.TotalSeconds; Logger.Info("{0, -35} : {1:F3} sec", string.Format("GetResponses time ({0}/{1})", clientC, config.BrokerClient), elapsedTimeSec); Logger.Info("{0, -35} : {1:F2} /sec", string.Format("GetResponses throughput ({0}/{1})", clientC, config.BrokerClient), responseNumber / elapsedTimeSec); } catch (Exception ex) { Logger.Error("Error occured getting responses.\n{0}", ex.ToString()); } } else { //wait for receiving responses async. done.WaitOne(); } } } catch (Exception e) { //swallow the exception in the thread. Logger.Error("Error occured in broker client thread.\n{0}", e.ToString()); } if (Interlocked.Decrement(ref clientNumber) == 0) { allDone.Set(); } }, g); } // for t Logger.Info("Wait for all broker clients."); allDone.WaitOne(); } catch (Exception e) { Logger.Error("Error occured.\n{0}", e.ToString()); } finally { if (session != null) { //explict close the session to free the resource session.Close(!config.ShareSession); session.Dispose(); } } //calc the request/response throughput for all broker client double allRequestsElapsedSeconds = (brokerSendRequestEndTime.Values.Max() - brokerSendRequestStartTime.Values.Min()).TotalSeconds; double allRequestThroughput = config.NumberOfRequest * config.BrokerClient / allRequestsElapsedSeconds; Logger.Info("{0, -35} : {1:F3} sec", "All requests sending time", allRequestsElapsedSeconds); Logger.Info("{0, -35} : {1:F2} /sec", "All requests throughput", allRequestThroughput); double allResponsesElapsedSeconds = (brokerGetResponseEndTime.Values.Max() - brokerGetResponseStartTime.Values.Min()).TotalSeconds; double allResponseThroughput = config.NumberOfRequest * config.BrokerClient / allResponsesElapsedSeconds; Logger.Info("{0, -35} : {1:F3} sec", "All resposnes receiving time", allResponsesElapsedSeconds); Logger.Info("{0, -35} : {1:F2} /sec", "All responses throughput", allResponseThroughput); //calc the min/max/average request e2e time double[] times = new double[config.NumberOfRequest * config.BrokerClient]; DateTime[] dates = new DateTime[config.NumberOfRequest * config.BrokerClient]; DateTime[] dates_req = new DateTime[config.NumberOfRequest * config.BrokerClient]; int k = 0; foreach (Guid g in brokerClientTaskTimeRecords.Keys) { foreach (TaskRecord r in brokerClientTaskTimeRecords[g].Values) { times[k] = (r.ResponseTime - r.RequestTime).TotalSeconds; dates[k] = r.ResponseTime; dates_req[k] = r.RequestTime; k++; } } Logger.Info("{0, -35} : {1:F3} sec", "Response time Min", times.Min()); Logger.Info("{0, -35} : {1:F3} sec", "Response time Max", times.Max()); Logger.Info("{0, -35} : {1:F3} sec", "Response time Ave", times.Average()); DateTime first = dates.Min(); DateTime last = dates.Max(); DateTime first_req = dates_req.Min(); double elapsedSec = (last - first).TotalSeconds; double elapsedSec_req = (last - first_req).TotalSeconds; Logger.Info("{0, -35} : {1:HH:mm:ss.fff}", "Response first", first); Logger.Info("{0, -35} : {1:HH:mm:ss.fff}", "Response last", last); Logger.Info("{0, -35} : {1:F3} sec", "Responses elapsed", elapsedSec); Logger.Info("{0, -35} : {1:F2} /sec", "Responses throughput", config.NumberOfRequest * config.BrokerClient / elapsedSec); Logger.Info("{0, -35} : {1:F3} sec", "Request E2E elapsed", elapsedSec_req); Logger.Info("{0, -35} : {1:F2} /sec", "Request E2E throughput", config.NumberOfRequest * config.BrokerClient / elapsedSec_req); Logger.Info("Echo Done."); }
static void Main(string[] args) { //Change headnode here const string headnode = "head.contoso.com"; const string serviceName = "PrimeFactorizationService"; SessionStartInfo info = new SessionStartInfo(headnode, serviceName); //Enable session pool info.ShareSession = true; info.UseSessionPool = true; try { //create an interactive session using (Session session = Session.CreateSession(info)) { Console.WriteLine("Session {0} has been created", session.Id); //in one session, each broker client should have a unique id string ClientId = Guid.NewGuid().ToString(); //use this event sync main thread and callback AutoResetEvent done = new AutoResetEvent(false); using (BrokerClient <IPrimeFactorization> client = new BrokerClient <IPrimeFactorization>(ClientId, session)) { Console.WriteLine("BrokerClient {0} has been created", ClientId); //set callback function. this handler will be invoke before service replies. client.SetResponseHandler <FactorizeResponse>((response) => { int number = response.GetUserData <int>(); int[] factors = response.Result.FactorizeResult; Console.WriteLine("{0} = {1}", number, string.Join <int>(" * ", factors)); //release the lock done.Set(); }); Random random = new Random(); int num = random.Next(1, Int32.MaxValue); //send request FactorizeRequest request = new FactorizeRequest(num); client.SendRequest <FactorizeRequest>(request, num); client.EndRequests(); //wait until callback returns done.WaitOne(); } Console.WriteLine("Factorization done."); Console.WriteLine("Press any key to exit"); Console.ReadKey(); } } catch (System.Exception ex) { Console.WriteLine(ex.Message); } }
static void Main(string[] args) { const string headnode = "[headnode]"; const string serviceName = "EchoService"; const int numRequests = 12; int count = 0; SessionStartInfo info = new SessionStartInfo(headnode, serviceName); AutoResetEvent done = new AutoResetEvent(false); Console.Write("Creating a session for EchoService..."); using (Session session = Session.CreateSession(info)) { Console.WriteLine("done session id = {0}", session.Id); NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport); using (BrokerClient <IService1> client = new BrokerClient <IService1>(session, binding)) { //set getresponse handler client.SetResponseHandler <EchoResponse>((item) => { try { Console.WriteLine("\tReceived response for request {0}: {1}", item.GetUserData <int>(), item.Result.EchoResult); } catch (SessionException ex) { Console.WriteLine("SessionException while getting responses in callback: {0}", ex.Message); } catch (Exception ex) { Console.WriteLine("Exception while getting responses in callback: {0}", ex.Message); } if (Interlocked.Increment(ref count) == numRequests) { done.Set(); } }); // start to send requests Console.Write("Sending {0} requests...", numRequests); for (int i = 0; i < numRequests; i++) { EchoRequest request = new EchoRequest("hello world!"); client.SendRequest <EchoRequest>(request, i); } client.EndRequests(); Console.WriteLine("done"); Console.WriteLine("Retrieving responses..."); // Main thread block here waiting for the retrieval process // to complete. As the thread that receives the "numRequests"-th // responses does a Set() on the event, "done.WaitOne()" will pop done.WaitOne(); Console.WriteLine("Done retrieving {0} responses", numRequests); } // Close connections and delete messages stored in the system session.Close(); } Console.WriteLine("Press any key to exit."); Console.Read(); }
public void doSubmit(Dictionary <string, string> runParameters) { m_start = System.Environment.TickCount; // // Configure session with cluster: // string[] parameterKeys = { "HeadNode", "Service", "JobTemplate", "Tasks", "TaskTime" }; foreach (string parameterKey in parameterKeys) { if (!runParameters.ContainsKey(parameterKey)) { outputError(parameterKey); } } string headNode = runParameters["HeadNode"]; SessionStartInfo info = new SessionStartInfo(headNode, runParameters["Service"]); info.SessionResourceUnitType = SessionUnitType.Core; if (runParameters.ContainsKey("MinCores")) { info.MinimumUnits = Convert.ToInt32(runParameters["MinCores"]); } if (runParameters.ContainsKey("MaxCores")) { info.MaximumUnits = Convert.ToInt32(runParameters["MaxCores"]); } if (runParameters.ContainsKey("Priority")) { info.SessionPriority = Convert.ToInt32(runParameters["Priority"]); } info.Secure = false; // generally off in the classroom: info.BrokerSettings.SessionIdleTimeout = 15000; // 15 secs: info.JobTemplate = runParameters["JobTemplate"]; int tasks = Convert.ToInt32(runParameters["Tasks"]); int taskTime = Convert.ToInt32(runParameters["TaskTime"]); double taskFailureChance = 0.0; if (runParameters.ContainsKey("TaskFailureChance")) { taskFailureChance = Convert.ToDouble(runParameters["TaskFailureChance"]); } int taskTimeDeviation = 0; if (runParameters.ContainsKey("TaskTimeDeviation")) { taskTimeDeviation = Convert.ToInt32(runParameters["TaskTimeDeviation"]); } int taskThrottling = 0; if (runParameters.ContainsKey("TaskThrottling")) { taskThrottling = Convert.ToInt32(runParameters["TaskThrottling"]); } // // User is prompted for run-as credentials, then session // is opened for business: // Session.SetInterfaceMode(false /*GUI*/, (IntPtr)0); Console.WriteLine("Creating session: {0}ms", System.Environment.TickCount - m_start); using (var session = Session.CreateSession(info)) { Console.WriteLine("Session Created: {0}ms", System.Environment.TickCount - m_start); var mode = (info.Secure) ? SecurityMode.Transport : SecurityMode.None; var binding = new NetTcpBinding(mode); using (var proxy = new BrokerClient <ClusterTesterService.IClusterTesterService>(session, binding)) { m_signal = new Semaphore(0, 1); proxy.SetResponseHandler <ClusterTesterService.RunTaskResponse>(doSubmit_ServiceCallback, m_signal); Console.WriteLine("Connected to session {0}: {1}ms", session.Id, System.Environment.TickCount - m_start); // // Make the N service calls: // Console.WriteLine("Sending requests: {0}", System.Environment.TickCount - m_start); Random random = new Random(); int thisTaskTime; for (int i = 0; i < tasks; i++) { if (taskTimeDeviation != 0) { thisTaskTime = Math.Max(0, gaussian(random, taskTime, taskTimeDeviation)); } else { thisTaskTime = taskTime; } if (taskThrottling > 0) { Thread.Sleep(taskThrottling); } proxy.SendRequest(new ClusterTesterService.RunTaskRequest(i, thisTaskTime, taskFailureChance)); } proxy.EndRequests(); Console.WriteLine("End requests: {0}ms", System.Environment.TickCount - m_start); // // wait on callbacks // m_signal.WaitOne(); session.Close(); } } Console.WriteLine("Exit program: {0}ms", System.Environment.TickCount - m_start); m_stop = System.Environment.TickCount; }