linux中pingpong测试程序的解读
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了linux中pingpong测试程序的解读，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含11412字，纯文字阅读大概需要17分钟。
内容图文
总代码放在最后。
抽象一点讲就是两个球员来回打球，一个发球，一个等待接球，最后计算完成指定数量的来回需要的时间。
详细一点：
程序定义了几个结构抽象出了pingpong游戏，如下：
//乒乓游戏的球员
typedef struct
{
int table;
int player;
int count;
pthread_mutex_t blocks[2];
pthread_t thread;
} player_t;
//打球的乒乓球台
typedef struct
{
int target;
int sleepms;
player_t players[2];
char pad[40]; /* avoids false cache
sharing */
} table_t;
//可以理解为用来控制比赛的裁判
typedef struct
{
pthread_mutex_t mx;
pthread_cond_t cv;
int target;
int count;
} barrier_t;首先就是各种初始化，根据指定的数量，创建n个乒乓球台（table_t），每个球台有两个运动员（player_t），编号分别为0号和1号。实质就是创建了n对线程，每队线程分别被标记为0号球员和1号球员，这个程序最终的目的其实就是实现一个球员发球时，另一个球员阻塞，等待对方发球。
为了实现这一点，pingpong使用了互斥锁，每个球员有两个互斥锁（blocks），这里创建的是默认属性的互斥锁，即当一个锁被一个线程锁上，那么只有这个线程才可以解锁，其他线程只能在其处于解锁状态才可以用，否则会陷入阻塞。我认为pingpong设计的很巧妙，在阻塞阶段，总会有一个被上锁，一个没有被上锁。两个球员交替为对方的上锁解锁，实现了上述功能。这部分代码位于（static void *player (void *arg)）函数，如下：
static void *
player (void *arg)
{
player_t *us, *them;
table_t *table;
struct timespec ts;
us = (player_t *) arg;
table = &(tables[us->table]);//当前球桌
them = &(table->players[(us->player + 1) % 2]);//表示对方球员
barrier_wait (&setup_barrier);//等待全部线程完成初始化
//由0号球员首发球
if (us->player == 0)//发球方
{
//加锁1号球员的全部锁
pthread_mutex_lock (&(them->blocks[0]));
pthread_mutex_lock (&(them->blocks[1]));
//等待主程序一声令下，开始！
barrier_wait (&begin_barrier);
//开始发球，解锁1号的锁0
pthread_mutex_unlock (&(them->blocks[0]));
}
else
{
//锁上0号的锁0
pthread_mutex_lock (&(them->blocks[0]));
//等待主程序一声令下，开始！
barrier_wait (&begin_barrier);
}
//两个球员来回打球，一个来回算一次，达到目标后退出循环
while (us->count < table->target){
pthread_mutex_lock (&(us->blocks[us->count % 2]));
pthread_mutex_lock (&(them->blocks[(us->count + us->player) % 2]));
pthread_mutex_unlock (&(us->blocks[us->count % 2]));
pthread_mutex_unlock (&
(them->blocks[(us->count + us->player + 1) % 2]));
us->count++;
//下面的操作用于同步所有线程完成一个来回
if (table->sleepms == -1)
{
pthread_mutex_lock (&bottleneck);
pthread_mutex_unlock (&bottleneck);
}
else if (table->sleepms > 0)
{
ts.tv_sec = table->sleepms / 1000;
ts.tv_nsec = (table->sleepms % 1000) * 1000000;
nanosleep (&ts, NULL);//暂停进程，等待ts毫秒
}
}
barrier_wait (&end_barrier);
return (NULL);
}
其中循环的前4个语句是关键，我画了一个图，参见下面：
0b0+表示0号球员的锁0被上锁
0b0-表示0号球员的锁0被解锁
(0b0+)表示在执行这个操作时，0号球员的锁0已经被上锁，不能访问，陷入阻塞，等待其解锁
空 表示阻塞中
其他依次类推
0号 1号
1b0+ 0b0+
1b1+
--------------------开始进行游戏
1b0- (1b0+)
(0b0+)
1b0+
0b1+
1b0-
0b0-
(1b1+)
0b0+
1b0+
0b0-
1b1-
(0b1+)
1b1+
0b0+
1b1-
0b1-
(1b0+)
0b1+
1b1+
0b1-
1b0-
(0b0+)
................循环往复pingpong.c全部代码
/*
* pp32.c: ping-pong threads benchmark
*
* gcc -O2 -pthread pp32.c -o pp32
*/
#include <pthread.h>
#include <stdlib.h>
#include <strings.h>
#include <stdio.h>
#include <time.h>
#include <sys/time.h>
#include <sys/mman.h>
/* a ping-pong player */
typedef struct
{
int table;
int player;
int count;
pthread_mutex_t blocks[2];
pthread_t thread;
} player_t;
/* a ping-pong table on which a rally is played */
typedef struct
{
int target;
int sleepms;
player_t players[2];
char pad[40]; /* avoids false cache
sharing */
} table_t;
/* a barrier used to pthread_processronise and time players */
typedef struct
{
pthread_mutex_t mx;
pthread_cond_t cv;
int target;
int count;
} barrier_t;
/* global arena of ping-pong tables */
static table_t *tables;
/* global lock used to create a bottleneck */
static pthread_mutex_t bottleneck;
/* player pthread_processonisation */
static barrier_t setup_barrier; /* all players ready */
static barrier_t begin_barrier; /* all games begin */
static barrier_t end_barrier; /* all games ended */
/* global pthread attributes - must call attr_init() before using! */
static pthread_mutexattr_t mxattr;
static pthread_condattr_t cvattr;
static pthread_attr_t ptattr;
/* forward references */
static void *player (void *arg);
static void setup_tables (int n, int target, int sleepms);
static void attr_init (int pthread_process, int sched, long stacksize);
static void barrier_init (barrier_t * b, int target);
static void barrier_wait (barrier_t * b);
static void tvsub (struct timeval *tdiff, struct timeval *t1,
struct timeval *t0);
static long long tvdelta (struct timeval *start, struct timeval *stop);
/* for getopt(3C) */
extern char *optarg;
extern int ptind;
/* verbose output flag */
static int verbose = 0;
int
main (int argc, char *argv[])
{
int c;
struct timeval t0, t1;
int ntables = 1;
int target = 1000000;
int sleepms = 0;
int concurrency = 0;
int resultonly = 0;
int pthread_scope = PTHREAD_SCOPE_PROCESS;
int pthread_process = PTHREAD_PROCESS_PRIVATE;
long stacksize = 0L;
int errflg = 0;
while ((c = getopt (argc, argv, "?vri:n:z:p:s:c:S:")) != EOF)
switch (c)
{
case '?':
errflg++;
continue;
case 'v':
verbose++;
continue;
case 'r':
resultonly++;
continue;
case 'i':
target = atoi (optarg);
continue;
case 'n':
ntables = atoi (optarg);
continue;
case 'z':
sleepms = atoi (optarg);
continue;
case 'p':
if (strcmp (optarg, "shared") == 0)
{
pthread_process = PTHREAD_PROCESS_SHARED;
}
else if (strcmp (optarg, "private") == 0)
{
pthread_scope = PTHREAD_PROCESS_PRIVATE;
}
else
{
errflg++;
}
continue;
case 's':
if (strcmp (optarg, "system") == 0)
{
pthread_scope = PTHREAD_SCOPE_SYSTEM;
}
else if (strcmp (optarg, "process") == 0)
{
pthread_scope = PTHREAD_SCOPE_PROCESS;
}
else
{
errflg++;
}
continue;
case 'c':
concurrency = atoi (optarg);
continue;
case 'S':
stacksize = atol (optarg);
continue;
default:
errflg++;
}
if (errflg > 0)
{
printf ("usage: pp [-v] [-i <target>] [-n <ntables>]"
" [-z <sleepms>]\n"
"[-p private|shared] [-s process|system]\n"
"[-c <concurrency>] [-S <stacksize>]\n");
exit (1);
}
if (verbose > 0)
{
printf ("\nPING-PONG CONFIGURATION:\n\n"
"target (-i) = %d\n"
"ntables (-n) = %d\n"
"sleepms (-z) = %d\n"
"pthread_scope (-s) = %s\n"
"pthread_process (-p) = %s\n"
"concurrency (-c) = %d\n"
"stacksize (-S) = %ld\n\n", target, ntables,
sleepms,
(pthread_scope ==
PTHREAD_SCOPE_PROCESS) ? "process" : "system",
(pthread_process ==
PTHREAD_PROCESS_PRIVATE) ? "private" : "shared",
concurrency, stacksize);
}
/* best to do this first! */
attr_init (pthread_process, pthread_scope, stacksize); //!!
/* initialise bottleneck */
pthread_mutex_init (&bottleneck, &mxattr);
/* initialise pthread_processronisation and timing points */
barrier_init (&setup_barrier, (2 * ntables) + 1);
barrier_init (&begin_barrier, (2 * ntables) + 1);
barrier_init (&end_barrier, (2 * ntables) + 1);
/* should not be needed - sigh! */
if (concurrency > 0)
{
pthread_setconcurrency (concurrency);
}
/* initialise all games */
if (gettimeofday (&t0, NULL))
{
fprintf (stderr, "gettimeofday failed\n");
exit (-1);
}
setup_tables (ntables, target, sleepms);
/* wait for all players to be ready */
barrier_wait (&setup_barrier);
if (gettimeofday (&t1, NULL))
{
fprintf (stderr, "gettimeofday failed\n");
exit (-1);
}
if (verbose)
{
// printf ("%d threads initialised in %lld msec\n", ntables * 2,
printf ("%d threads initialised in %lld usec\n", ntables * 2,
tvdelta (&t0, &t1));
}
if (resultonly)
{
printf("%lld\n", tvdelta(&t0, &t1));
}
/* start all games */
if (gettimeofday (&t0, NULL))
{
fprintf (stderr, "gettimeofday failed\n");
exit (-1);
}
barrier_wait (&begin_barrier);
/* wait for all games to complete */
barrier_wait (&end_barrier);
if (gettimeofday (&t1, NULL))
{
fprintf (stderr, "gettimeofday failed\n");
exit (-1);
}
if (verbose)
{
printf ("%d games completed in %lld usec\n", ntables,
tvdelta (&t0, &t1));
}
if (resultonly)
{
printf("%lld\n", tvdelta(&t0, &t1));
}
return (0);
}
/*
* build and populate the tables
*/
static void
setup_tables (int n, int target, int sleepms)
{
int i, j;
int res;
tables =
(void *) mmap (NULL, n * sizeof (table_t), PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANON, -1, 0L);
if (tables == (table_t *) (-1))
{
exit (1);
}
for (i = 0; i < n; i++)
{
tables[i].target = target;
tables[i].sleepms = sleepms;
for (j = 0; j < 2; j++)
{
tables[i].players[j].table = i;
tables[i].players[j].player = j;
tables[i].players[j].count = 0;
pthread_mutex_init (&(tables[i].players[j].blocks[0]), &mxattr);
pthread_mutex_init (&(tables[i].players[j].blocks[1]), &mxattr);
res =
pthread_create (&(tables[i].players[j].thread), &ptattr,
player, &(tables[i].players[j]));
if (res != 0)
{
printf
("Failed while creating new thread: your system can support %d threads only as much as possible\n",
i*2+j);
exit (1);
}
}
}
}
/*
* a ping-pong player
*/
static void *
player (void *arg)
{
player_t *us, *them;
table_t *table;
struct timespec ts;
us = (player_t *) arg;
table = &(tables[us->table]);
them = &(table->players[(us->player + 1) % 2]);
barrier_wait (&setup_barrier);
/* player 0 always serves */
if (us->player == 0)
{
pthread_mutex_lock (&(them->blocks[0]));
pthread_mutex_lock (&(them->blocks[1]));
barrier_wait (&begin_barrier);
/* serve! */
pthread_mutex_unlock (&(them->blocks[0]));
}
else
{
pthread_mutex_lock (&(them->blocks[0]));
barrier_wait (&begin_barrier);
}
while (us->count < table->target)
{
/* wait to be unblocked */
pthread_mutex_lock (&(us->blocks[us->count % 2]));
/* block their next + 1 move */
pthread_mutex_lock (&(them->blocks[(us->count + us->player) % 2]));
/* let them block us again */
pthread_mutex_unlock (&(us->blocks[us->count % 2]));
/* unblock their next move */
pthread_mutex_unlock (&
(them->blocks[(us->count + us->player + 1) % 2]));
us->count++;
if (table->sleepms == -1)
{
pthread_mutex_lock (&bottleneck);
pthread_mutex_unlock (&bottleneck);
}
else if (table->sleepms > 0)
{
ts.tv_sec = table->sleepms / 1000;
ts.tv_nsec = (table->sleepms % 1000) * 1000000;
nanosleep (&ts, NULL);
}
}
barrier_wait (&end_barrier);
return (NULL);
}
/*
* simple, non-spinning barrier wait mechinism
*/
static void
barrier_wait (barrier_t * b)
{
pthread_mutex_lock (&b->mx);
b->count++;
if (b->count >= b->target)
{
pthread_mutex_unlock (&b->mx);
pthread_cond_broadcast (&b->cv);
return;
}
while (b->count < b->target)
{
pthread_cond_wait (&b->cv, &b->mx);
}
pthread_mutex_unlock (&b->mx);
}
/*
* initialise a barrier (ok to reinitialise object if no
waiters)
*/
static void
barrier_init (barrier_t * b, int target)
{
pthread_mutex_init (&b->mx, &mxattr);
pthread_cond_init (&b->cv, &cvattr);
b->target = target;
b->count = 0;
}
/*
* initialise the global pthread attributes
*/
static void
attr_init (int pthread_process, int pthread_scope, long stacksize)
{
pthread_mutexattr_init (&mxattr);
pthread_mutexattr_setpshared (&mxattr, pthread_process);
pthread_condattr_init (&cvattr);
pthread_condattr_setpshared (&cvattr, pthread_process);
pthread_attr_init (&ptattr);
pthread_attr_setscope (&ptattr, pthread_scope);
if (stacksize > 0)
{
pthread_attr_setstacksize (&ptattr, stacksize);
}
}
static void
tvsub (struct timeval *tdiff, struct timeval *t1, struct timeval *t0)
{
tdiff->tv_sec = t1->tv_sec - t0->tv_sec;
tdiff->tv_usec = t1->tv_usec - t0->tv_usec;
if (tdiff->tv_usec < 0 && tdiff->tv_sec > 0)
{
tdiff->tv_sec--;
tdiff->tv_usec += 1000000;
if (tdiff->tv_usec <= 0)
{
fprintf (stderr, "time counting error!\n");
exit (2);
}
}
/* time shouldn't go backwards!!! */
if (tdiff->tv_usec < 0 || t1->tv_sec < t0->tv_sec)
{
tdiff->tv_sec = 0;
tdiff->tv_usec = 0;
}
}
static long long
tvdelta (struct timeval *start, struct timeval *stop)
{
struct timeval td;
long long usecs;
tvsub (&td, stop, start);
usecs = td.tv_sec;
usecs *= 1000000;
usecs += td.tv_usec;
return (usecs);
}
内容总结
以上是互联网集市为您收集整理的linux中pingpong测试程序的解读全部内容，希望文章能够帮你解决linux中pingpong测试程序的解读所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。
来源：【匿名】