Question about concurrency and sessions

First, when you say "asynchronous" calls do you mean IsOneWay calls or AsyncPattern calls? If the latter, on which side: Client or service?

As to the WSHttpBinding stuff you have to realize that http is by definition two-way; services do not fire off the http response (empty, in the case of one-way) until processing has finished on the service. This holds up the channel instance. This is an implementation detail of that binding, which is why tcp doesn't work that way -- the session is a different type of session. It would work the way you expect, too, if you had a UDP channel.

RalphSquillace at 2007-10-3 >

I havn't done any test, i've just read documentation. And i'm not taking into account
the session mode.

Bye.

Marzullo at 2007-10-3 >

Yes, I also think that there is something strange with my tests. I just cannot figure out what.
I'm sending the code attached to this post.

Pedro Felix

namespace Concurrency
{
[ServiceContract]
public interface IService
{
[OperationContract]
string Operation1(string s);

}

[ServiceContract]
public interface IAsyncService
{
[OperationContract(Action = "http://tempuri.org/IService/Operation1", ReplyAction = "http://tempuri.org/IService/Operation1Response")]
string Operation1(string s);

[OperationContract(AsyncPattern = true, Action = "http://tempuri.org/IService/Operation1", ReplyAction = "http://tempuri.org/IService/Operation1Response")]
System.IAsyncResult BeginOperation1(string s, System.AsyncCallback callback, object asyncState);

string EndOperation1(System.IAsyncResult result);
}

//-- Implementation
[ServiceBehavior]
class ServiceImpl : IService
{
public static volatile bool begin = false;
public static volatile bool end = false;
public string Operation1(string s)
{
if(begin == true){
if(end == true) Console.WriteLine("Sequential");
else Console.WriteLine("Concurrent");
}
begin = true;
Thread.Sleep(4000);
end = true;
return s.ToUpper();
}
}

delegate void ServiceCaller<CT>(CT channel, string s);

class Program
{
static void
RunTestCase<CT>(SessionMode sm, InstanceContextMode icm, ConcurrencyMode cm, Binding b, string address, ServiceCaller<CT> action)
{
Console.Write("{0} {1} {2} {3} => ",
sm, icm, cm, b.GetType().Name);
ServiceHost sh = new ServiceHost(typeof(ServiceImpl), new Uri(address));
sh.AddServiceEndpoint(typeof(IService), b, "ep1");
sh.Description.Endpoints[0].Contract.SessionMode = sm;
ServiceBehaviorAttribute sb = sh.Description.Behaviors.Find<ServiceBehaviorAttribute>();
if (sb == null)
{
sb = new ServiceBehaviorAttribute();
}
sb.InstanceContextMode = icm;
sb.ConcurrencyMode = cm;
try
{
ServiceImpl.begin = false;
ServiceImpl.end = false;

sh.Open();

ChannelFactory<CT> cf = new ChannelFactory<CT>(b, address + "/ep1");
cf.Endpoint.Contract.SessionMode = sm;
CT[] ch = new CT[2];
ch[0] = cf.CreateChannel();
ch[1] = cf.CreateChannel();
ICommunicationObject ico = ch[0] as ICommunicationObject;
ico.Open();
ico = ch[1] as ICommunicationObject;
ico.Open();

Semaphore sem = new Semaphore(0, 2);
for (int i = 0; i < 2; ++i)
{
int ix = i;
ThreadPool.QueueUserWorkItem(
delegate{
action(ch[0], Thread.CurrentThread.ManagedThreadId.ToString());
sem.Release();
});
}
sem.WaitOne();
sem.WaitOne();
(ch[0] as IClientChannel).Close();
(ch[1] as IClientChannel).Close();

sh.Close();

}catch(Exception exc){
Console.WriteLine("exception thrown ", exc.Message);
if(sh.State == CommunicationState.Opened) sh.Close();
}
}

static void Main(string[] args)
{
SessionMode[] sma = { SessionMode.NotAllowed, SessionMode.Required };
InstanceContextMode[] icma = { InstanceContextMode.PerCall, InstanceContextMode.PerSession };
ConcurrencyMode[] cma = {ConcurrencyMode.Single, ConcurrencyMode.Multiple};
Binding[] ba = {
new BasicHttpBinding(),
new NetTcpBinding(),
//new WSHttpBinding(SecurityMode.None,false),
new WSHttpBinding(SecurityMode.None,true)

};
string[] aa = {
"http://localhost:8080/concurrency",
"net.tcp://localhost:8080/concurrency",
//"http://localhost:8080/concurrency",
"http://localhost:8088/concurrency"
};

foreach (SessionMode sm in sma)
{
foreach (InstanceContextMode icm in icma)
{
foreach(ConcurrencyMode cm in cma){
for (int i = 0; i < ba.Length; ++i)
{

RunTestCase<IService>(sm, icm, cm, ba, aa,
delegate(IService ch, string s) { ch.Operation1(s); }
);

/*
RunTestCase<IAsyncService>(sm, icm, cm, ba, aa,
delegate(IAsyncService ch, string s)
{
IAsyncResult ar = ch.BeginOperation1(s, null, null);
ch.EndOperation1(ar);
}
);
*/
}
}
}
}
Console.WriteLine("press any key to exit");
Console.ReadKey();
}
}
}

PedroFelix at 2007-10-3 >

Hi Felix,

I tried the following scenario of configuring a service with InstanceContextMode.PerCall and implementing a sessionful contract with SessionMode.Required and I see that each call results in a new instance of the service being created, which looks like the expected behavior.

Do you see a different behavior?

Thanks

RamVenkatesan-MSFT at 2007-10-3 >

Hello

It has been a while since I've though on those problems. From what I can recall, the problem was not on the instancing behavior but on the concurrency behavior. I've updated my code to show if the service is using the same instance or different instances. The results were:

NotAllowed PerCall Single BasicHttpBinding => Different instance, Concurrent
NotAllowed PerCall Single NetTcpBinding => exception thrown
NotAllowed PerCall Single WSHttpBinding => Different instance, Concurrent
NotAllowed PerCall Multiple BasicHttpBinding => Different instance, Concurrent
NotAllowed PerCall Multiple NetTcpBinding => exception thrown
NotAllowed PerCall Multiple WSHttpBinding => Different instance, Concurrent
NotAllowed PerSession Single BasicHttpBinding => Different instance, Concurrent
NotAllowed PerSession Single NetTcpBinding => exception thrown
NotAllowed PerSession Single WSHttpBinding => Different instance, Concurrent
NotAllowed PerSession Multiple BasicHttpBinding => Different instance, Concurrent
NotAllowed PerSession Multiple NetTcpBinding => exception thrown
NotAllowed PerSession Multiple WSHttpBinding => Different instance, Concurrent
Required PerCall Single BasicHttpBinding => exception thrown
Required PerCall Single NetTcpBinding => Different instance, Sequential a)
Required PerCall Single WSHttpBinding => Different instance, Sequential b)
Required PerCall Multiple BasicHttpBinding => exception thrown
Required PerCall Multiple NetTcpBinding => Different instance, Concurrent
Required PerCall Multiple WSHttpBinding => Different instance, Sequential c)
Required PerSession Single BasicHttpBinding => exception thrown
Required PerSession Single NetTcpBinding => Same instance, Sequential
Required PerSession Single WSHttpBinding => Same instance, Sequential
Required PerSession Multiple BasicHttpBinding => exception thrown
Required PerSession Multiple NetTcpBinding => Same instance, Concurrent
Required PerSession Multiple WSHttpBinding => Same instance, Sequential d)

The red lines correspond to unexpected (at least to me) behavior:

1) The instancing behavior seems to be always ok: "same instance" only happens when sessions are "Required" and InstanceContextMode is "PerSession".

2) The concurrency does not seem to be according to the specs, namely:

cenario a): the behavior should be concurrent, since the instances are different.

cenario b): as above

cenario c): the behavior should be concurrent, since the instances are different. Notice that the same scenario with NetTcpBindigs results in the expected concurrent behavior

cenario d): as above

Perhaps there is a bug hidden in my test code

Pedro Felix

PedroFelix at 2007-10-3 >