Lecture notes for CS 509, Advanced Programming II

Lecture Notes for CS 509, Advanced Programming II

3 March 2004 - Thread Iterators

Outline

Client-server testing.
Removing loops from code.
Defining your own iterators.

Client-Server Computing

Client-server computing splits askers (clients) and responders (servers).
Servers should be able to handle hundreds of clients.
- Stress testing servers with hundreds of clients is a pain.
A multi-threaded client can from hundreds of connections with a server.

Creating Threads

Creating threads is relatively simple.

static void *
client(void * arg)
  // whatever

main() 
  const unsigned max = max_open_files()
  pthread_t tids[max]

  for (i = 0; i < max; i++)
    if pthread_create(tids + i, client, i)
      error("pthread create failed")

  for (i = 0; i < max; i++)
    if pthread_join(tids[i], NULL)
      error("pthread join failed")

But - eeek! - it has loops in it. Can we get rid of them?

Joining Threads

What is the second loop doing?

for (i = 0; i < max; i++)
  if pthread_join(tids[i], NULL)
    error("pthread join failed")

For each thread, wait for it to end.
- Ah, that's std::for_each()
What's the function?
- It should only have one parameter.
- std::for_each() ignores the return value, no error checking.
- Create our own function that does what we want.
```
static void
join(pthread_t tid)
  if pthread_join(tid, NULL)
    error("pthread join failed")
```
And we're done.
```
std::for_each(tids, tids + max, join)
```

Creating Threads

Can we get rid of the first loop? What does it do?

for i = 0; i < max; i++
  if pthread_create(tids + i, f, i)
    perror("pthread_create() failed")

Create a thread and store the id in tids.

std::generate() does that, but what's the function?
- It should take no parameters, and return the thread id.
- We can do that.
```
static pthread_t
ptc() 
  pthread_t tid
  if pthread_create(&tid, f, 0)
    perror("pthread_create() failed")
  return tid
```
- Notice the thread argument.
And we're done.
```
std::generate(tids, tids + max, ptc)
```

Non-Loopy Code

Now we have code with no loops.

static pthread_t
ptc() 
  pthread_t tid
  if pthread_create(&tid, f, 0)
    perror("pthread_create() failed")
  return tid

static void
join(pthread_t tid)
  if pthread_join(tid, NULL)
    error("pthread join failed")

main() 
  const unsigned max = max_open_files()
  pthread_t tids[max]

  std::generate(tids, tids + max, ptc)
  std::for_each(tids, tids + max, join)

Are we happy?
- Well, suppose we want a variable number of threads?

Vector-Based Thread Creation

Using vectors makes having a dynamic number of threads easy and safe.

main() 
  int cnt
  std::cin >> cnt
  std::vector<pthread_t> tids(cnt)

  std::generate(
    tids.begin(), tids.end(), ptc)
  std::for_each(
    tids.begin(), tids.end(), join)

But what's with that constructor?
- It avoids the mutating-algorithm trap.
Why can't we use a back-inserter?
- That would work as a destination, but what's the source?
Wouldn't it be cool if we had thread iterators?
- Yeah, way cool! What are thread iterators?

Thread Iterators

A thread iterator makes a thread and returns the id when accessed.
- It's an input iterator, because it produces values.
Input iterator operations *, ++, ==, and ->.
- R-value * should return the id of the current thread.
  - It may have to create the thread too.
- Pre- and postfix ++ each create a new thread.
  - What do *++ti and *it++ do for thread iterator ti?
- Two thread iterators are equal of they've produced the same number of threads.
  - The thread main() doesn't enter into it, although it could.
- The arrow operator isn't defined for thread ids.

Implementing Thread Iterators

To implement a thread iterator, we need
1. The thread main().
2. The most recently created thread's id.
3. The count of threads created.

class thread_iterator 

  public:

    thread_iterator() 
      : cnt(0), tmain(0), tid(0)

    thread_iterator(int i, void* (*f)(void*)) 
      : cnt(i), tmain(f), tid(0)

    thread_iterator(const thread_iterator & i) 
      : cnt(i.cnt) tmain(i.tmain) tid(i.tid)

  private:

    unsigned cnt
    void * (* tmain)(void *)
    pthread_t tid

Implementing the Methods

The follow operator.

pthread_t operator * ()
  if (tid == 0) and (cnt > 0)
    ptc(tid, --cnt)
  return tid

The follow operator uses on-demand (or lazy) evaluation.

The pre- and post-increment operators.

thread_iterator operator ++ ()
  if cnt > 0
    ptc(tid, --cnt)
  return *this


thread_iterator operator ++ (int)
  thread_iterator old(*this)
  if cnt > 0
    ptc(tid, --cnt)
  return old

Now you see why ++it is chepar than it++.

Implementing the Methods, Continued

The equality test.

bool 
operator == (const thread_iterator & ti)
  return cnt == ti.cnt

bool 
operator != (const thread_iterator & ti)
  return not this->operator == (ti)

A private method to create threads.

void ptc(pthread_t & tid, int arg)
  if pthread_create(&tid, tmain, arg)
    error("pthread create failed")

Using Thread Iterators

$ cat ti.cc
int main()

  const unsigned max = 3
  std::vector<pthread_t> tids

  std::copy(thread_iterator(max, client),
	    thread_iterator(),
	    std::back_inserter(tids))
  std::for_each(tids.begin(), tids.end(), join)

$ g++ -o ti -ansi -pedantic ti.cc -lpthread

$ ./ti
thread thread thread thread 2 is alive.
3 is alive.
0 is alive.
1 is alive.

$ CC -o ti ti.cc -lpthread

$ ./ti
thread 0 is alive.
thread 1 is alive.
thread 2 is alive.
thread 3 is alive.

$

See the complete code.

Points to Remember

Loopy code makes you dizzy.
- Replace loops with generic algorithms.
Generic algorithms ofter require auxiliary functions.
- This is the no-lambda problem .
Avoid dynamic memory.
- Use the STL instead.
Make data look like sequences, make iterators for the sequences.
- Making iterators if fun and easy (especially if you ignore the standard).

This page last modified on 12 March 2004.