बूस्ट गणित (ibeta_inv फ़ंक्शन) थ्रेड सुरक्षित नहीं है?

Question

मैंने बढ़ावा देने का हिस्सा संकलित किया है - ibeta_inv फ़ंक्शन - .Net 64 बिट असेंबली में और यह तब तक अच्छा काम करता है जब तक कि मैंने इसे एकाधिक थ्रेड से कॉल करना शुरू नहीं किया। फिर यह मौलिक रूप से गलत परिणाम देता है।

// Boost.h 

#pragma once 

#include <boost/math/special_functions/beta.hpp> 

using namespace boost::math; 

namespace Boost { 

    public ref class BoostMath 
    { 
    public: 
     double static InverseIncompleteBeta(double a, double b, double x) 
     { 
      return ibeta_inv(a,b,x); 
     } 
    }; 
} 

किसी को भी करने से पहले इस की कोशिश की है:

मैं इस कोड (C++/CLI) का उपयोग कर यह पालन किया?

मैंने इसे बाहर नहीं किया है। नेट, इसलिए मुझे नहीं पता कि यह कारण क्या है, लेकिन मुझे वास्तव में यह नहीं पता कि क्यों, यह महान एकल थ्रेडेड काम करता है।

प्रयोग (सी #):

private void calcBoost(List<Val> vals) 
{ 
    //gives WRONG results (sometimes): 
    vals.AsParallel().ForAll(v => v.BoostResult = BoostMath.InverseIncompleteBeta(v.A, v.B, v.X)); 
    //gives CORRECT results: 
    vals.ForEach(v => v.BoostResult = BoostMath.InverseIncompleteBeta(v.A, v.B, v.X)); 
} 

अद्यतन: जैसा कि नीचे मेरी टिप्पणी में देखा जा सकता है - मैं सब पर अब और है कि यह एक बूस्ट समस्या है यकीन नहीं है। शायद यह कुछ अजीब PLinq सी ++/सीएलआई बग ??? मैं blaffed हूँ और बाद में और तथ्यों के साथ वापस आ जाएगा।

Answer 1

मुझे सी ++/सीएलआई 64 बिट प्रोजेक्ट में बढ़ावा देने के हिस्से को समाहित किया गया है और इसे ठीक से सी # से उपयोग करें।

तो मैं अपने ही बूस्ट आवरण में अपनी सी ++ वर्ग में फेंक दिया और सी # परियोजना के लिए इस कोड कहा:

private class Val 
    { 
     public double A; 
     public double B; 
     public double X; 
     public double ParallellResult; 
    } 

    private static void findParallelError() 
    { 
     var r = new Random(); 

     while (true) 
     { 
      var vals = new List<Val>(); 
      for (var i = 0; i < 1000*1000; i++) 
      { 
       var val = new Val(); 
       val.A = r.NextDouble()*100; 
       val.B = val.A + r.NextDouble()*1000; 
       val.X = r.NextDouble(); 
       vals.Add(val); 
      } 

      // parallel calculation 
      vals.AsParallel().ForAll(v => v.ParallellResult = Boost.BoostMath.InverseIncompleteBeta(v.A, v.B, v.X)); 

      /sequential verification 
      var error = vals.Exists(v => v.ParallellResult != Boost.BoostMath.InverseIncompleteBeta(v.A, v.B, v.X)); 
      if (error) 
       return; 
     } 
    } 

और यह सिर्फ निष्पादित करता है "हमेशा के लिए"। समानांतर परिणाम अनुक्रमिक परिणामों के बराबर होते हैं। यहां कोई धागा असुरक्षित नहीं है ...

क्या मैं सुझाव देता हूं कि आप बूस्ट की ताजा प्रति डाउनलोड करें और इसे पूरी तरह से नई परियोजना में शामिल करें और इसे आजमाएं?

मुझे यह भी पता है कि आपने अपना परिणाम "बूस्ट रिसेट" कहा है ... और "हमारे वर्तमान कार्यान्वयन" के बारे में कुछ टिप्पणियों में उल्लेख किया है। वास्तव में आप अपने परिणाम की तुलना फिर से कर रहे हैं? "सही" की आपकी परिभाषा क्या है?

Answer 2

यह महत्वपूर्ण है कि Val कक्षा थ्रेडसेफ है।

यह सुनिश्चित करने का एक आसान तरीका यह अपरिवर्तनीय बनाना होगा, लेकिन मुझे लगता है कि आपके पास BoostResult भी लिखा जाना चाहिए। तो उसे volatile होना चाहिए, या लॉकिंग का कुछ रूप होना चाहिए।

public sealed class Val 
{ 
    // Immutable fields are inheriently threadsafe 
    public readonly double A; 
    public readonly double B; 
    public readonly double X; 

    // volatile is an easy way to make a single field thread safe 
    // box and unbox to allow double as volatile 
    private volatile object boostResult = 0.0; 

    public Val(double A, double B, double X) 
    { 
     this.A = A; 
     this.B = B; 
     this.X = X; 
    } 

    public double BoostResult 
    { 
     get 
     { 
      return (double)boostResult; 
     } 
     set 
     { 
      boostResult = value; 
     } 
    } 
} 

ताला संस्करण: (this question देख निर्धारित करने के लिए जो आपके आवेदन के लिए सबसे उचित होगा)

public sealed class Val 
{ 
    public readonly double A; 
    public readonly double B; 
    public readonly double X; 

    private readonly object lockObject = new object(); 
    private double boostResult; 

    public Val(double A, double B, double X) 
    { 
     this.A = A; 
     this.B = B; 
     this.X = X; 
    } 

    public double BoostResult 
    { 
     get 
     { 
      lock (lockObject) 
      { 
       return boostResult; 
      } 
     } 
     set 
     { 
      lock (lockObject) 
      { 
       boostResult = value; 
      } 
     } 
    } 
} 

और अगर आपको लगता 6 लाख ताले धीमी गति से हो जाएगा, सिर्फ इस प्रयास करें:

using System; 

namespace ConsoleApplication17 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      { //without locks 
       var startTime = DateTime.Now; 
       int i2=0; 
       for (int i = 0; i < 6000000; i++) 
       { 
        i2++; 
       } 
       Console.WriteLine(i2); 
       Console.WriteLine(DateTime.Now.Subtract(startTime)); //0.01 seconds on my machine 
      } 
      { //with locks 
       var startTime = DateTime.Now; 
       var obj = new Object(); 
       int i2=0; 
       for (int i = 0; i < 6000000; i++) 
       { 
        lock (obj) 
        { 
         i2++; 
        } 
       } 
       Console.WriteLine(i2); 
       Console.WriteLine(DateTime.Now.Subtract(startTime)); //0.14 seconds on my machine, and this isn't even in parallel. 
      } 
      Console.ReadLine(); 
     } 
    } 
}