Parallelization in WCF

Question

I create WCF service with Spring.NET framework. This service is math service and provide some computations for client apps.

I have question about WCF service parallelization on multi-core server. For simple example I have server with 20 cores.

First here is a simplified code.

//WS interface
public interface IMatlabService
{
    List<ResultData> Calculate(byte [] data);
}

//WS class definition
[ServiceBehavior(Namespace = "http://server.com/MatlabService")]
public class MatlabService: IMatlabService
{
    public IMatlabManager MatlabManager{get;set:}

    //web metod for math computations
    public List<ResultData> Calculate(byte [] data)
    {
        var result = new List<ResultData>();

        //do math work in another thread
        Task<List<ResultData>> task = Task.Factory.StartNew<List<ResultData>>(() =>
                                                           {
                                                               return MatlabManager.CalculateWithFiniteElementMethod(data);
                                                           });

        result.AddRange(task.Result)

        return result;

    }
}

public interface IMatlabManager 
{
    List<ResultData> CalculateWithFiniteElementMethod(byte [] data);
}

public class MatlabManager : IMatlabManager 
{
    public List<ResultData> CalculateWithFiniteElementMethod(byte [] data)
    {
        // do some math work
    }
}

With Spring.NET I configure web service and manager class as not singleton.

Spring.NET XML configuration is here.

Matlab manager configuration:

  <object name="matlabManager"
          type="MatlabManager"
          singleton="false"/>

MatlabService configuration:

  <object name="matlabService"
          type="MatlabService"
          singleton="false">
       <property name="MatlabManager" ref="matlabManager"/>
  </object>

WCF service configuration from web.config

 <behavior name="Behavior1">
     <serviceMetadata httpGetEnabled="true"/>
     <serviceDebug includeExceptionDetailInFaults="true"/>
  </behavior>

<services>
  <service name="matlabService" 
            behaviorConfiguration="Behavior1">
    <endpoint address="" 
            binding="basicHttpBinding" 
            contract="IMatlabService" 
            bindingNamespace="http://server.com/MatlabService"/>
    <endpoint contract="IMetadataExchange" 
            binding="mexHttpBinding" 
            address="mex"/>
  </service>
</services>

SVC file.

<%@ ServiceHost Language="C#" Debug="true" Service="MatlabServiceService" Factory="Spring.ServiceModel.Activation.ServiceHostFactory" %>

I believe for each client web metod call is created new instance of MatlabService and WCF service work is do on new thread (WCF service thread) and OS assign this thread to CPU core.

Or I am wrong and behavior create new service object per call I must define in ServiceBehavior property InstanceContextMode?

[ServiceBehavior(InstanceContextMode=InstanceContextMode.PerCall)]
In web method Calculate of MatlabService I use System.Threading.Tasks for parallelization so math work is do in another thread (Math thread).

For each call is created WCF service thread and in WCF service thread is created Math thread.

I am not sure if this is true.

Maybe is needed allow multi-threading in WCF service in ConcurrencyMode?

[ServiceBehavior(InstanceContextMode=InstanceContextMode.PerCall,ConcurrencyMode = ConcurrencyMode.Multiple)]

I would like heard ideas how can parallelize web metod calls for multi core CPU. I google it but not find any clear and usefull for me because I use Spring.NET framework for creation WCF service.

RQDQ RQDQ · Accepted Answer · 2012-09-07T20:16:17

The default instance context mode is PerCall, so setting that explicitly is redundant.
Yes, you're creating an additional thread to do the math operations, but you're not gaining anything because you're blocking until the task is complete. In fact, it is less efficient because you have the overhead of creating and mangaging an additional thread.

Each web call is already serviced in its own thread.

The only place I can see to add additional parallel computing is within the implementation of:

MatlabManager.CalculateWithFiniteElementMethod(data)

However, that looks like a call to Matlab. If you can reimplement that method using parallel code, you might be able to eek out some performance gains.

Whatever you do, profiling is the key to understanding if you're actually making it faster. Remember - parallel doesn't always mean faster. There is overhead in synchronizing these operations and creating the threads for them.

Parallelization in WCF

1 Answers