هل تطبيق C++ هذا للطفو الذري آمن؟
https://stackoverflow.com/questions/242172
-
04-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russianسؤال
يحرر: الكود هنا لا يزال يحتوي على بعض الأخطاء، ويمكن أن يعمل بشكل أفضل في قسم الأداء، ولكن بدلاً من محاولة إصلاح ذلك، للعلم، نقلت المشكلة إلى مجموعات مناقشة Intel وحصلت على الكثير من التعليقات الرائعة، وإذا كل شيء يسير على ما يرام، سيتم تضمين نسخة مصقولة من Atomic float في إصدار قريب من Intel Threading Building Blocks
حسنًا، هذا أمر صعب، أريد تعويمًا ذريًا، ليس لأداء رسومات فائق السرعة، ولكن لاستخدامه بشكل روتيني كأعضاء بيانات في الفئات.ولا أريد أن أدفع ثمن استخدام الأقفال في هذه الفئات، لأنها لا توفر أي فوائد إضافية لاحتياجاتي.
الآن مع tbb من Intel والمكتبات الذرية الأخرى التي رأيتها، يتم دعم الأنواع الصحيحة، ولكن ليس النقاط العائمة.لذلك واصلت ونفذت واحدة، وهي تعمل ...لكنني لست متأكدًا مما إذا كان الأمر يعمل حقًا، أم أنني محظوظ جدًا لأنه يعمل.
هل يعرف أي شخص هنا ما إذا كان هذا ليس شكلاً من أشكال بدعة الخيط؟
typedef unsigned int uint_32;
struct AtomicFloat
{
private:
tbb::atomic<uint_32> atomic_value_;
public:
template<memory_semantics M>
float fetch_and_store( float value )
{
const uint_32 value_ = atomic_value_.tbb::atomic<uint_32>::fetch_and_store<M>((uint_32&)value);
return reinterpret_cast<const float&>(value_);
}
float fetch_and_store( float value )
{
const uint_32 value_ = atomic_value_.tbb::atomic<uint_32>::fetch_and_store((uint_32&)value);
return reinterpret_cast<const float&>(value_);
}
template<memory_semantics M>
float compare_and_swap( float value, float comparand )
{
const uint_32 value_ = atomic_value_.tbb::atomic<uint_32>::compare_and_swap<M>((uint_32&)value,(uint_32&)compare);
return reinterpret_cast<const float&>(value_);
}
float compare_and_swap(float value, float compare)
{
const uint_32 value_ = atomic_value_.tbb::atomic<uint_32>::compare_and_swap((uint_32&)value,(uint_32&)compare);
return reinterpret_cast<const float&>(value_);
}
operator float() const volatile // volatile qualifier here for backwards compatibility
{
const uint_32 value_ = atomic_value_;
return reinterpret_cast<const float&>(value_);
}
float operator=(float value)
{
const uint_32 value_ = atomic_value_.tbb::atomic<uint_32>::operator =((uint_32&)value);
return reinterpret_cast<const float&>(value_);
}
float operator+=(float value)
{
volatile float old_value_, new_value_;
do
{
old_value_ = reinterpret_cast<float&>(atomic_value_);
new_value_ = old_value_ + value;
} while(compare_and_swap(new_value_,old_value_) != old_value_);
return (new_value_);
}
float operator*=(float value)
{
volatile float old_value_, new_value_;
do
{
old_value_ = reinterpret_cast<float&>(atomic_value_);
new_value_ = old_value_ * value;
} while(compare_and_swap(new_value_,old_value_) != old_value_);
return (new_value_);
}
float operator/=(float value)
{
volatile float old_value_, new_value_;
do
{
old_value_ = reinterpret_cast<float&>(atomic_value_);
new_value_ = old_value_ / value;
} while(compare_and_swap(new_value_,old_value_) != old_value_);
return (new_value_);
}
float operator-=(float value)
{
return this->operator+=(-value);
}
float operator++()
{
return this->operator+=(1);
}
float operator--()
{
return this->operator+=(-1);
}
float fetch_and_add( float addend )
{
return this->operator+=(-addend);
}
float fetch_and_increment()
{
return this->operator+=(1);
}
float fetch_and_decrement()
{
return this->operator+=(-1);
}
};
شكرًا!
يحرر: تم تغيير size_t إلى uint32_t كما اقترح جريج روجرز، وبهذه الطريقة يكون أكثر قابلية للحمل
يحرر: تمت إضافة قائمة لكل شيء، مع بعض الإصلاحات.
المزيد من التعديلات: الأداء الحكيم باستخدام تعويم مقفل لإجراء 5.000.000 += عمليات مع 100 مؤشر ترابط على جهازي يستغرق 3.6 ثانية، في حين أن التعويم الذري الخاص بي حتى مع القيام به السخيف يستغرق 0.2 ثانية للقيام بنفس العمل.لذا فإن تعزيز الأداء الذي يزيد عن 30 ضعفًا يعني أن الأمر يستحق العناء، (وهذا هو المصيد) إذا كان صحيحًا.
المزيد من التعديلات: كما أشار Awgn بلدي fetch_and_xxxx الأجزاء كلها كانت خاطئة.تم إصلاح ذلك وإزالة أجزاء من واجهة برمجة التطبيقات (API) التي لست متأكدًا منها (نماذج الذاكرة القالبة).ونفذت عمليات أخرى من حيث عامل التشغيل += لتجنب تكرار التعليمات البرمجية
تمت الإضافة: تمت إضافة عامل التشغيل *= وعامل التشغيل /=، نظرًا لأن العوامات لن تكون عوامات بدونها.بفضل تعليق Peterchen الذي تم ملاحظته
يحرر: يتبع أحدث إصدار من الكود (سأترك الإصدار القديم كمرجع)
#include <tbb/atomic.h>
typedef unsigned int uint_32;
typedef __TBB_LONG_LONG uint_64;
template<typename FLOATING_POINT,typename MEMORY_BLOCK>
struct atomic_float_
{
/* CRC Card -----------------------------------------------------
| Class: atmomic float template class
|
| Responsability: handle integral atomic memory as it were a float,
| but partially bypassing FPU, SSE/MMX, so it is
| slower than a true float, but faster and smaller
| than a locked float.
| *Warning* If your float usage is thwarted by
| the A-B-A problem this class isn't for you
| *Warning* Atomic specification says we return,
| values not l-values. So (i = j) = k doesn't work.
|
| Collaborators: intel's tbb::atomic handles memory atomicity
----------------------------------------------------------------*/
typedef typename atomic_float_<FLOATING_POINT,MEMORY_BLOCK> self_t;
tbb::atomic<MEMORY_BLOCK> atomic_value_;
template<memory_semantics M>
FLOATING_POINT fetch_and_store( FLOATING_POINT value )
{
const MEMORY_BLOCK value_ =
atomic_value_.tbb::atomic<MEMORY_BLOCK>::fetch_and_store<M>((MEMORY_BLOCK&)value);
//atomic specification requires returning old value, not new one
return reinterpret_cast<const FLOATING_POINT&>(value_);
}
FLOATING_POINT fetch_and_store( FLOATING_POINT value )
{
const MEMORY_BLOCK value_ =
atomic_value_.tbb::atomic<MEMORY_BLOCK>::fetch_and_store((MEMORY_BLOCK&)value);
//atomic specification requires returning old value, not new one
return reinterpret_cast<const FLOATING_POINT&>(value_);
}
template<memory_semantics M>
FLOATING_POINT compare_and_swap( FLOATING_POINT value, FLOATING_POINT comparand )
{
const MEMORY_BLOCK value_ =
atomic_value_.tbb::atomic<MEMORY_BLOCK>::compare_and_swap<M>((MEMORY_BLOCK&)value,(MEMORY_BLOCK&)compare);
//atomic specification requires returning old value, not new one
return reinterpret_cast<const FLOATING_POINT&>(value_);
}
FLOATING_POINT compare_and_swap(FLOATING_POINT value, FLOATING_POINT compare)
{
const MEMORY_BLOCK value_ =
atomic_value_.tbb::atomic<MEMORY_BLOCK>::compare_and_swap((MEMORY_BLOCK&)value,(MEMORY_BLOCK&)compare);
//atomic specification requires returning old value, not new one
return reinterpret_cast<const FLOATING_POINT&>(value_);
}
operator FLOATING_POINT() const volatile // volatile qualifier here for backwards compatibility
{
const MEMORY_BLOCK value_ = atomic_value_;
return reinterpret_cast<const FLOATING_POINT&>(value_);
}
//Note: atomic specification says we return the a copy of the base value not an l-value
FLOATING_POINT operator=(FLOATING_POINT rhs)
{
const MEMORY_BLOCK value_ = atomic_value_.tbb::atomic<MEMORY_BLOCK>::operator =((MEMORY_BLOCK&)rhs);
return reinterpret_cast<const FLOATING_POINT&>(value_);
}
//Note: atomic specification says we return an l-value when operating among atomics
self_t& operator=(self_t& rhs)
{
const MEMORY_BLOCK value_ = atomic_value_.tbb::atomic<MEMORY_BLOCK>::operator =((MEMORY_BLOCK&)rhs);
return *this;
}
FLOATING_POINT& _internal_reference() const
{
return reinterpret_cast<FLOATING_POINT&>(atomic_value_.tbb::atomic<MEMORY_BLOCK>::_internal_reference());
}
FLOATING_POINT operator+=(FLOATING_POINT value)
{
FLOATING_POINT old_value_, new_value_;
do
{
old_value_ = reinterpret_cast<FLOATING_POINT&>(atomic_value_);
new_value_ = old_value_ + value;
//floating point binary representation is not an issue because
//we are using our self's compare and swap, thus comparing floats and floats
} while(self_t::compare_and_swap(new_value_,old_value_) != old_value_);
return (new_value_); //return resulting value
}
FLOATING_POINT operator*=(FLOATING_POINT value)
{
FLOATING_POINT old_value_, new_value_;
do
{
old_value_ = reinterpret_cast<FLOATING_POINT&>(atomic_value_);
new_value_ = old_value_ * value;
//floating point binary representation is not an issue becaus
//we are using our self's compare and swap, thus comparing floats and floats
} while(self_t::compare_and_swap(new_value_,old_value_) != old_value_);
return (new_value_); //return resulting value
}
FLOATING_POINT operator/=(FLOATING_POINT value)
{
FLOATING_POINT old_value_, new_value_;
do
{
old_value_ = reinterpret_cast<FLOATING_POINT&>(atomic_value_);
new_value_ = old_value_ / value;
//floating point binary representation is not an issue because
//we are using our self's compare and swap, thus comparing floats and floats
} while(self_t::compare_and_swap(new_value_,old_value_) != old_value_);
return (new_value_); //return resulting value
}
FLOATING_POINT operator-=(FLOATING_POINT value)
{
return this->operator+=(-value); //return resulting value
}
//Prefix operator
FLOATING_POINT operator++()
{
return this->operator+=(1); //return resulting value
}
//Prefix operator
FLOATING_POINT operator--()
{
return this->operator+=(-1); //return resulting value
}
//Postfix operator
FLOATING_POINT operator++(int)
{
const FLOATING_POINT temp = this;
this->operator+=(1);
return temp//return resulting value
}
//Postfix operator
FLOATING_POINT operator--(int)
{
const FLOATING_POINT temp = this;
this->operator+=(1);
return temp//return resulting value
}
FLOATING_POINT fetch_and_add( FLOATING_POINT addend )
{
const FLOATING_POINT old_value_ = atomic_value_;
this->operator+=(addend);
//atomic specification requires returning old value, not new one as in operator x=
return old_value_;
}
FLOATING_POINT fetch_and_increment()
{
const FLOATING_POINT old_value_ = atomic_value_;
this->operator+=(+1);
//atomic specification requires returning old value, not new one as in operator x=
return old_value_;
}
FLOATING_POINT fetch_and_decrement()
{
const FLOATING_POINT old_value_ = atomic_value_;
this->operator+=(-1);
//atomic specification requires returning old value, not new one as in operator x=
return old_value_;
}
};
typedef atomic_float_<float,uint_32> AtomicFloat;
typedef atomic_float_<double,uint_64> AtomicDouble;
المحلول
أنصح بشدة بعدم الميراث العام.لا أعرف كيف يبدو التنفيذ الذري، لكنني أفترض أنه يحتوي على مشغلين مثقلين يستخدمونه كنوع متكامل، مما يعني أنه سيتم استخدام هذه الترقيات بدلاً من تعويمك في العديد من الحالات (ربما معظمها؟).
لا أرى أي سبب لعدم نجاح ذلك، لكن مثلك لا بد لي من طريقة لإثبات ذلك...
ملاحظة واحدة:لك operator float() لا يحتوي الروتين على دلالات اكتساب التحميل، ألا يجب وضع علامة عليه const volatile (أو بالتأكيد على الأقل const)؟
يحرر:إذا كنت ستقدم عامل التشغيل --() فيجب عليك تقديم كلا النموذجين البادئة/اللاحقة.
نصائح أخرى
يبدو أن التنفيذ الخاص بك يفترض ذلك sizeof(size_t) == sizeof(float).هل سيكون هذا صحيحًا دائمًا بالنسبة لمنصاتك المستهدفة؟
ولن أقول خيوط بدعة بقدر ما يصب بدعة - هرطقة.:)
على الرغم من أن حجم أ uint32_t قد يكون معادلاً لـ أ يطفو على قوس معين، من خلال إعادة تفسير قالب من واحد إلى الآخر، فإنك تفترض ضمنيًا أن الزيادات الذرية والتناقصات وجميع العمليات الأخرى على البتات متكافئة لغويًا في كلا النوعين، وهي ليست كذلك في الواقع.أشك في أنه يعمل كما هو متوقع.
أشك بشدة في حصولك على القيم الصحيحة في fetch_and_add وما إلى ذلك، حيث أن الإضافة العائمة تختلف عن الإضافة الصحيحة.
إليك ما أحصل عليه من هذه الحسابات:
1 + 1 = 1.70141e+038
100 + 1 = -1.46937e-037
100 + 0.01 = 1.56743e+038
23 + 42 = -1.31655e-036
لذا نعم، Threadsafe ولكن ليس ما تتوقعه.
يجب أن تعمل الخوارزميات الخالية من القفل (المشغل + وما إلى ذلك) فيما يتعلق بالذرية (لم يتم التحقق من الخوارزمية نفسها ..)
حل آخر:نظرًا لأن الأمر عبارة عن عمليات إضافة وطرح، فقد تتمكن من إعطاء كل سلسلة مثيلًا خاصًا بها، ثم إضافة النتائج من سلاسل رسائل متعددة.
هذه هي حالة الكود كما هي الآن بعد المحادثات على لوحات المعلومات، ولكن لم يتم التحقق بشكل كامل حتى الآن من أنها تعمل بشكل صحيح في جميع السيناريوهات.
#include <tbb/atomic.h>
typedef unsigned int uint_32;
typedef __TBB_LONG_LONG uint_64;
template<typename FLOATING_POINT,typename MEMORY_BLOCK>
struct atomic_float_
{
/* CRC Card -----------------------------------------------------
| Class: atmomic float template class
|
| Responsability: handle integral atomic memory as it were a float,
| but partially bypassing FPU, SSE/MMX, so it is
| slower than a true float, but faster and smaller
| than a locked float.
| *Warning* If your float usage is thwarted by
| the A-B-A problem this class isn't for you
| *Warning* Atomic specification says we return,
| values not l-values. So (i = j) = k doesn't work.
|
| Collaborators: intel's tbb::atomic handles memory atomicity
----------------------------------------------------------------*/
typedef typename atomic_float_<FLOATING_POINT,MEMORY_BLOCK> self_t;
tbb::atomic<MEMORY_BLOCK> atomic_value_;
template<memory_semantics M>
FLOATING_POINT fetch_and_store( FLOATING_POINT value )
{
const MEMORY_BLOCK value_ =
atomic_value_.tbb::atomic<MEMORY_BLOCK>::fetch_and_store<M>((MEMORY_BLOCK&)value);
//atomic specification requires returning old value, not new one
return reinterpret_cast<const FLOATING_POINT&>(value_);
}
FLOATING_POINT fetch_and_store( FLOATING_POINT value )
{
const MEMORY_BLOCK value_ =
atomic_value_.tbb::atomic<MEMORY_BLOCK>::fetch_and_store((MEMORY_BLOCK&)value);
//atomic specification requires returning old value, not new one
return reinterpret_cast<const FLOATING_POINT&>(value_);
}
template<memory_semantics M>
FLOATING_POINT compare_and_swap( FLOATING_POINT value, FLOATING_POINT comparand )
{
const MEMORY_BLOCK value_ =
atomic_value_.tbb::atomic<MEMORY_BLOCK>::compare_and_swap<M>((MEMORY_BLOCK&)value,(MEMORY_BLOCK&)compare);
//atomic specification requires returning old value, not new one
return reinterpret_cast<const FLOATING_POINT&>(value_);
}
FLOATING_POINT compare_and_swap(FLOATING_POINT value, FLOATING_POINT compare)
{
const MEMORY_BLOCK value_ =
atomic_value_.tbb::atomic<MEMORY_BLOCK>::compare_and_swap((MEMORY_BLOCK&)value,(MEMORY_BLOCK&)compare);
//atomic specification requires returning old value, not new one
return reinterpret_cast<const FLOATING_POINT&>(value_);
}
operator FLOATING_POINT() const volatile // volatile qualifier here for backwards compatibility
{
const MEMORY_BLOCK value_ = atomic_value_;
return reinterpret_cast<const FLOATING_POINT&>(value_);
}
//Note: atomic specification says we return the a copy of the base value not an l-value
FLOATING_POINT operator=(FLOATING_POINT rhs)
{
const MEMORY_BLOCK value_ = atomic_value_.tbb::atomic<MEMORY_BLOCK>::operator =((MEMORY_BLOCK&)rhs);
return reinterpret_cast<const FLOATING_POINT&>(value_);
}
//Note: atomic specification says we return an l-value when operating among atomics
self_t& operator=(self_t& rhs)
{
const MEMORY_BLOCK value_ = atomic_value_.tbb::atomic<MEMORY_BLOCK>::operator =((MEMORY_BLOCK&)rhs);
return *this;
}
FLOATING_POINT& _internal_reference() const
{
return reinterpret_cast<FLOATING_POINT&>(atomic_value_.tbb::atomic<MEMORY_BLOCK>::_internal_reference());
}
FLOATING_POINT operator+=(FLOATING_POINT value)
{
FLOATING_POINT old_value_, new_value_;
do
{
old_value_ = reinterpret_cast<FLOATING_POINT&>(atomic_value_);
new_value_ = old_value_ + value;
//floating point binary representation is not an issue because
//we are using our self's compare and swap, thus comparing floats and floats
} while(self_t::compare_and_swap(new_value_,old_value_) != old_value_);
return (new_value_); //return resulting value
}
FLOATING_POINT operator*=(FLOATING_POINT value)
{
FLOATING_POINT old_value_, new_value_;
do
{
old_value_ = reinterpret_cast<FLOATING_POINT&>(atomic_value_);
new_value_ = old_value_ * value;
//floating point binary representation is not an issue becaus
//we are using our self's compare and swap, thus comparing floats and floats
} while(self_t::compare_and_swap(new_value_,old_value_) != old_value_);
return (new_value_); //return resulting value
}
FLOATING_POINT operator/=(FLOATING_POINT value)
{
FLOATING_POINT old_value_, new_value_;
do
{
old_value_ = reinterpret_cast<FLOATING_POINT&>(atomic_value_);
new_value_ = old_value_ / value;
//floating point binary representation is not an issue because
//we are using our self's compare and swap, thus comparing floats and floats
} while(self_t::compare_and_swap(new_value_,old_value_) != old_value_);
return (new_value_); //return resulting value
}
FLOATING_POINT operator-=(FLOATING_POINT value)
{
return this->operator+=(-value); //return resulting value
}
//Prefix operator
FLOATING_POINT operator++()
{
return this->operator+=(1); //return resulting value
}
//Prefix operator
FLOATING_POINT operator--()
{
return this->operator+=(-1); //return resulting value
}
//Postfix operator
FLOATING_POINT operator++(int)
{
const FLOATING_POINT temp = this;
this->operator+=(1);
return temp//return resulting value
}
//Postfix operator
FLOATING_POINT operator--(int)
{
const FLOATING_POINT temp = this;
this->operator+=(1);
return temp//return resulting value
}
FLOATING_POINT fetch_and_add( FLOATING_POINT addend )
{
const FLOATING_POINT old_value_ = atomic_value_;
this->operator+=(addend);
//atomic specification requires returning old value, not new one as in operator x=
return old_value_;
}
FLOATING_POINT fetch_and_increment()
{
const FLOATING_POINT old_value_ = atomic_value_;
this->operator+=(+1);
//atomic specification requires returning old value, not new one as in operator x=
return old_value_;
}
FLOATING_POINT fetch_and_decrement()
{
const FLOATING_POINT old_value_ = atomic_value_;
this->operator+=(-1);
//atomic specification requires returning old value, not new one as in operator x=
return old_value_;
}
};
typedef atomic_float_<float,uint_32> AtomicFloat;
typedef atomic_float_<double,uint_64> AtomicDouble;
مجرد ملاحظة حول هذا (أردت أن أدلي بتعليق ولكن يبدو أنه لا يُسمح للمستخدمين الجدد بالتعليق):يؤدي استخدام reinterpret_cast على المراجع إلى ظهور رمز غير صحيح مع gcc 4.1 -O3.يبدو أن هذا قد تم إصلاحه في الإصدار 4.4 لأنه يعمل هناك.إن تغيير reinterpret_casts إلى مؤشرات، على الرغم من كونه أقبح قليلاً، إلا أنه يعمل في كلتا الحالتين.
من خلال قراءتي لهذا الكود، سأكون غاضبًا جدًا من مثل هذا المترجم الذي قام بطرح تجميع لهذا لم يكن ذريًا.
اطلب من المترجم الخاص بك إنشاء رمز التجميع وإلقاء نظرة عليه.إذا كانت العملية أكثر من تعليمات لغة تجميع واحدة، فهي كذلك لا عملية ذرية، وتتطلب أقفالًا لتعمل بشكل صحيح في الأنظمة متعددة المعالجات.
لسوء الحظ، لست متأكدًا من أن العكس هو الصحيح أيضًا - تلك العمليات ذات التعليمات المفردة نكون مضمونة أن تكون ذرية.لا أعرف تفاصيل برمجة المعالجات المتعددة حتى هذا المستوى.يمكنني أن أدافع عن أي من النتيجتين.(إذا كان أي شخص آخر لديه معلومات محددة حول ذلك، فلا تتردد في المشاركة.)
