パフォーマンステスト：sem_t vs dispatch_semaphore_tおよびpthread_once_t vs dispatch_once_t
https://stackoverflow.com/questions/3640853
-
30-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian質問
私は、何がより良い/より速いものを知りたいと思っていました。 pthread_once() と sem_wait() または、Dispatch_*関数があるので、少しテストを作成し、結果に驚いています（質問と結果は最後にあります）。
テストコードでは、Mach_absolute_time（）を使用して呼び出しを計算しています。これがナノ秒と正確に一致していないことは本当に気にしません。私は値を互いに比較しているので、正確な時間単位は重要ではなく、間隔の違いだけが重要ではありません。結果セクションの数値は繰り返し可能であり、平均化されていません。私は時代を平均していたかもしれませんが、私は正確な数字を探していません。
test.m（簡単なコンソールアプリケーション、コンパイルが簡単）：
#import <Foundation/Foundation.h>
#import <dispatch/dispatch.h>
#include <semaphore.h>
#include <pthread.h>
#include <time.h>
#include <mach/mach_time.h>
// *sigh* OSX does not have pthread_barrier (you can ignore the pthread_barrier
// code, the interesting stuff is lower)
typedef int pthread_barrierattr_t;
typedef struct
{
pthread_mutex_t mutex;
pthread_cond_t cond;
int count;
int tripCount;
} pthread_barrier_t;
int pthread_barrier_init(pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count)
{
if(count == 0)
{
errno = EINVAL;
return -1;
}
if(pthread_mutex_init(&barrier->mutex, 0) < 0)
{
return -1;
}
if(pthread_cond_init(&barrier->cond, 0) < 0)
{
pthread_mutex_destroy(&barrier->mutex);
return -1;
}
barrier->tripCount = count;
barrier->count = 0;
return 0;
}
int pthread_barrier_destroy(pthread_barrier_t *barrier)
{
pthread_cond_destroy(&barrier->cond);
pthread_mutex_destroy(&barrier->mutex);
return 0;
}
int pthread_barrier_wait(pthread_barrier_t *barrier)
{
pthread_mutex_lock(&barrier->mutex);
++(barrier->count);
if(barrier->count >= barrier->tripCount)
{
barrier->count = 0;
pthread_cond_broadcast(&barrier->cond);
pthread_mutex_unlock(&barrier->mutex);
return 1;
}
else
{
pthread_cond_wait(&barrier->cond, &(barrier->mutex));
pthread_mutex_unlock(&barrier->mutex);
return 0;
}
}
//
// ok you can start paying attention now...
//
void onceFunction(void)
{
}
@interface SemaphoreTester : NSObject
{
sem_t *sem1;
sem_t *sem2;
pthread_barrier_t *startBarrier;
pthread_barrier_t *finishBarrier;
}
@property (nonatomic, assign) sem_t *sem1;
@property (nonatomic, assign) sem_t *sem2;
@property (nonatomic, assign) pthread_barrier_t *startBarrier;
@property (nonatomic, assign) pthread_barrier_t *finishBarrier;
@end
@implementation SemaphoreTester
@synthesize sem1, sem2, startBarrier, finishBarrier;
- (void)thread1
{
pthread_barrier_wait(startBarrier);
for(int i = 0; i < 100000; i++)
{
sem_wait(sem1);
sem_post(sem2);
}
pthread_barrier_wait(finishBarrier);
}
- (void)thread2
{
pthread_barrier_wait(startBarrier);
for(int i = 0; i < 100000; i++)
{
sem_wait(sem2);
sem_post(sem1);
}
pthread_barrier_wait(finishBarrier);
}
@end
int main (int argc, const char * argv[])
{
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
int64_t start;
int64_t stop;
// semaphore non contention test
{
// grrr, OSX doesn't have sem_init
sem_t *sem1 = sem_open("sem1", O_CREAT, 0777, 0);
start = mach_absolute_time();
for(int i = 0; i < 100000; i++)
{
sem_post(sem1);
sem_wait(sem1);
}
stop = mach_absolute_time();
sem_close(sem1);
NSLog(@"0 Contention time = %d", stop - start);
}
// semaphore contention test
{
__block sem_t *sem1 = sem_open("sem1", O_CREAT, 0777, 0);
__block sem_t *sem2 = sem_open("sem2", O_CREAT, 0777, 0);
__block pthread_barrier_t startBarrier;
pthread_barrier_init(&startBarrier, NULL, 3);
__block pthread_barrier_t finishBarrier;
pthread_barrier_init(&finishBarrier, NULL, 3);
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
dispatch_async(queue, ^{
pthread_barrier_wait(&startBarrier);
for(int i = 0; i < 100000; i++)
{
sem_wait(sem1);
sem_post(sem2);
}
pthread_barrier_wait(&finishBarrier);
});
dispatch_async(queue, ^{
pthread_barrier_wait(&startBarrier);
for(int i = 0; i < 100000; i++)
{
sem_wait(sem2);
sem_post(sem1);
}
pthread_barrier_wait(&finishBarrier);
});
pthread_barrier_wait(&startBarrier);
// start timing, everyone hit this point
start = mach_absolute_time();
// kick it off
sem_post(sem2);
pthread_barrier_wait(&finishBarrier);
// stop timing, everyone hit the finish point
stop = mach_absolute_time();
sem_close(sem1);
sem_close(sem2);
NSLog(@"2 Threads always contenting time = %d", stop - start);
pthread_barrier_destroy(&startBarrier);
pthread_barrier_destroy(&finishBarrier);
}
// NSTask semaphore contention test
{
sem_t *sem1 = sem_open("sem1", O_CREAT, 0777, 0);
sem_t *sem2 = sem_open("sem2", O_CREAT, 0777, 0);
pthread_barrier_t startBarrier;
pthread_barrier_init(&startBarrier, NULL, 3);
pthread_barrier_t finishBarrier;
pthread_barrier_init(&finishBarrier, NULL, 3);
SemaphoreTester *tester = [[[SemaphoreTester alloc] init] autorelease];
tester.sem1 = sem1;
tester.sem2 = sem2;
tester.startBarrier = &startBarrier;
tester.finishBarrier = &finishBarrier;
[NSThread detachNewThreadSelector:@selector(thread1) toTarget:tester withObject:nil];
[NSThread detachNewThreadSelector:@selector(thread2) toTarget:tester withObject:nil];
pthread_barrier_wait(&startBarrier);
// start timing, everyone hit this point
start = mach_absolute_time();
// kick it off
sem_post(sem2);
pthread_barrier_wait(&finishBarrier);
// stop timing, everyone hit the finish point
stop = mach_absolute_time();
sem_close(sem1);
sem_close(sem2);
NSLog(@"2 NSTasks always contenting time = %d", stop - start);
pthread_barrier_destroy(&startBarrier);
pthread_barrier_destroy(&finishBarrier);
}
// dispatch_semaphore non contention test
{
dispatch_semaphore_t sem1 = dispatch_semaphore_create(0);
start = mach_absolute_time();
for(int i = 0; i < 100000; i++)
{
dispatch_semaphore_signal(sem1);
dispatch_semaphore_wait(sem1, DISPATCH_TIME_FOREVER);
}
stop = mach_absolute_time();
NSLog(@"Dispatch 0 Contention time = %d", stop - start);
}
// dispatch_semaphore non contention test
{
__block dispatch_semaphore_t sem1 = dispatch_semaphore_create(0);
__block dispatch_semaphore_t sem2 = dispatch_semaphore_create(0);
__block pthread_barrier_t startBarrier;
pthread_barrier_init(&startBarrier, NULL, 3);
__block pthread_barrier_t finishBarrier;
pthread_barrier_init(&finishBarrier, NULL, 3);
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
dispatch_async(queue, ^{
pthread_barrier_wait(&startBarrier);
for(int i = 0; i < 100000; i++)
{
dispatch_semaphore_wait(sem1, DISPATCH_TIME_FOREVER);
dispatch_semaphore_signal(sem2);
}
pthread_barrier_wait(&finishBarrier);
});
dispatch_async(queue, ^{
pthread_barrier_wait(&startBarrier);
for(int i = 0; i < 100000; i++)
{
dispatch_semaphore_wait(sem2, DISPATCH_TIME_FOREVER);
dispatch_semaphore_signal(sem1);
}
pthread_barrier_wait(&finishBarrier);
});
pthread_barrier_wait(&startBarrier);
// start timing, everyone hit this point
start = mach_absolute_time();
// kick it off
dispatch_semaphore_signal(sem2);
pthread_barrier_wait(&finishBarrier);
// stop timing, everyone hit the finish point
stop = mach_absolute_time();
NSLog(@"Dispatch 2 Threads always contenting time = %d", stop - start);
pthread_barrier_destroy(&startBarrier);
pthread_barrier_destroy(&finishBarrier);
}
// pthread_once time
{
pthread_once_t once = PTHREAD_ONCE_INIT;
start = mach_absolute_time();
for(int i = 0; i <100000; i++)
{
pthread_once(&once, onceFunction);
}
stop = mach_absolute_time();
NSLog(@"pthread_once time = %d", stop - start);
}
// dispatch_once time
{
dispatch_once_t once = 0;
start = mach_absolute_time();
for(int i = 0; i <100000; i++)
{
dispatch_once(&once, ^{});
}
stop = mach_absolute_time();
NSLog(@"dispatch_once time = %d", stop - start);
}
[pool drain];
return 0;
}
私のiMac（Snow Leopard Server 10.6.4）：
Model Identifier: iMac7,1 Processor Name: Intel Core 2 Duo Processor Speed: 2.4 GHz Number Of Processors: 1 Total Number Of Cores: 2 L2 Cache: 4 MB Memory: 4 GB Bus Speed: 800 MHz
わかりました：
0 Contention time = 101410439 2 Threads always contenting time = 109748686 2 NSTasks always contenting time = 113225207 0 Contention named semaphore time = 166061832 2 Threads named semaphore contention time = 203913476 2 NSTasks named semaphore contention time = 204988744 Dispatch 0 Contention time = 3411439 Dispatch 2 Threads always contenting time = 708073977 pthread_once time = 2707770 dispatch_once time = 87433
私のmacbookpro（Snow Leopard 10.6.4）：
Model Identifier: MacBookPro6,2 Processor Name: Intel Core i5 Processor Speed: 2.4 GHz Number Of Processors: 1 Total Number Of Cores: 2 (though HT is enabled) L2 Cache (per core): 256 KB L3 Cache: 3 MB Memory: 8 GB Processor Interconnect Speed: 4.8 GT/s
手に入れた：
0 Contention time = 74172042 2 Threads always contenting time = 82975742 2 NSTasks always contenting time = 82996716 0 Contention named semaphore time = 106772641 2 Threads named semaphore contention time = 162761973 2 NSTasks named semaphore contention time = 162919844 Dispatch 0 Contention time = 1634941 Dispatch 2 Threads always contenting time = 759753865 pthread_once time = 1516787 dispatch_once time = 120778
iPhone3GS4.0.2で私は得ました：
0 Contention time = 5971929 2 Threads always contenting time = 11989710 2 NSTasks always contenting time = 11950564 0 Contention named semaphore time = 16721876 2 Threads named semaphore contention time = 35333045 2 NSTasks named semaphore contention time = 35296579 Dispatch 0 Contention time = 151909 Dispatch 2 Threads always contenting time = 46946548 pthread_once time = 193592 dispatch_once time = 25071
質問と声明：
sem_wait()とsem_post()競合していないときは遅いです- なぜそうなのですか？
- OSXは互換性のあるAPIを気にしませんか？これを強制するレガシーコードはありますか？
- なぜこれらの数字はDispatch_semaphore機能と同じではないのですか？
sem_wait()とsem_post()競合していない場合と同じくらい遅いです（違いはありますが、それは競合の下では大きな違いであると思いました。sem_wait()とsem_post()名前付きセマフォを使用すると遅くなります。- なんで？これは、セマフォをプロセス間で同期する必要があるためですか？それをするとき、もっともっと荷物があるかもしれません。
dispatch_semaphore_wait()とdispatch_semaphore_signal()競合しないときはクレイジーです（Appleがこれをたくさん宣伝しているので、ここでは驚きではありません）。dispatch_semaphore_wait()とdispatch_semaphore_signal()3倍遅いsem_wait()とsem_post()競合しているとき- なぜこれがそんなに遅いのですか？これは私には意味がありません。私はこれが競合の下でSEM_Tと同等であると予想していたでしょう。
dispatch_once()より速いですpthread_once(), 、約10倍、なぜですか？ヘッダーから私が言うことができる唯一のことは、関数のコール負担がないということですdispatch_once()とよりpthread_once().
動機：私は2セットのツールを提示して、セマフォの仕事を終わらせるか、電話をかけると一度電話をかけます（その間に他のセマフォのバリアントを実際に見つけましたが、より良い選択肢として育てられない限り、それらを無視します）。私はただ仕事に最適なツールを知りたいだけです（フィリップスやフラットヘッドでネジをねじ込むオプションがある場合は、ネジをトルクする必要がない場合はフィリップスを選びますネジをトルクします）。 Libdispatchでユーティリティの作成を開始した場合、まだLibdispatchが機能していない他のオペレーティングシステムに移植できないようですが、使用するのはとても魅力的です;）
現状では、ポータビリティやPOSIXコールを心配する必要がないときは、Libdispatchを使用します。
ありがとう！
解決
sem_wait（）およびsem_post（）は、プロセス間で使用できる重量同期施設です。それらは常にカーネルへの往復旅行を伴い、おそらくあなたのスレッドのスケジュールを変更する必要があります。それらは一般に、インプロセスの同期のための正しい選択ではありません。名前付きバリアントが匿名のバリエーションよりも遅くなる理由はわかりません...
Mac OS Xは、実際にはPOSIXの互換性についてかなり優れています...しかし、POSIX仕様には多くのオプション機能があり、Macにはすべてがありません。あなたの投稿は実際に私がPTHREAD_BARRIERESについて聞いたことがある最初のものなので、それらが比較的最近であるか、それほど一般的ではないと思います。 （私は過去10年ほどの間、Pthreadsの進化にあまり注意を払っていません。）
強制的な極端な競合の下で派遣のものがバラバラになる理由は、おそらくカバーの下で動作がスピンロックに似ているためです。あなたの派遣ワーカーのスレッドは、競合の下にあるリソースが今ではあらゆるサイクルになるという楽観的な仮定の下で、彼らの量子のかなりの部分を無駄にしている可能性が非常に高いです...サメとの少し時間は確かにあなたに伝えます。ただし、持ち帰りのポイントは、競合中のスラッシングがプログラマ時間の投資不良であることを「最適化」することです。代わりに、コードの最適化に時間を費やします 避ける そもそも重い争い。
プロセス内で避けられないボトルネックであるリソースが本当にある場合、その周りにセマフォを置くことは非常に最適です。独自のシリアルディスパッチキューに置き、そのキューで実行される可能性のあるDispatch_asyncブロックに置きます。
最後に、Dispatch_once（）は、PTHREAD_ONCE（）よりも高速です。おそらく、AppleはPTHREAD_ONCE（）の実装をスピードアップできます。参照実装ではPTHREAD同期プリミティブを使用していると思われますが、... :-)
所属していません StackOverflow
