Re: configuring gdb 5.x for use with threads

[peter@a59252.upc-a.chello.nl]

[-- Attachment #1: Type: text/plain, Size: 2470 bytes --]

Hi,.

I rebuild my glibc+linuxthreads 2.2.4 agains my linuxkernel 2.4.15-pre5 SMP, a libthread_db-1.0.so was build.
I rebuild gdb 2001-11-16-cvs, it detected thread_db.h, even loads libthread_db.so.1 on startup. However I still can't debug multi-threaded apps. 

here's some output and the programm used to generate it.

can someone please tell me what I've done wrong or point me to the docs, I'll read.

regards,
Peter Zijlstra

---

peter@twins queue $ gcc -ggdb3 -o test test.c queue.c -D_REENTRANT -lpthread
peter@twins queue $ gdb ./test
GNU gdb 2001-11-16-cvs
Copyright 2001 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB.  Type "show warranty" for details.
This GDB was configured as "i686-pc-linux-gnu"...
(gdb) run
Starting program: /home/peter/code/queue/./test 

Program received signal SIG32, Real-time event 32.
0x40068bc9 in sigsuspend () from /lib/libc.so.6
(gdb) bt
#0  0x40068bc9 in sigsuspend () from /lib/libc.so.6
#1  0x4002d6cf in pthread_getconcurrency () from /lib/libpthread.so.0
#2  0x4002ce99 in pthread_create () from /lib/libpthread.so.0
#3  0x08049206 in queue_create (queue_size_=16, workers_=3, reaper_=0x804890c <my_reaper>) at queue.c:160
#4  0x0804896e in main (argc=1, argv=0xbffff834) at test.c:38
#5  0x40057921 in __libc_start_main () from /lib/libc.so.6
(gdb) cont
Continuing.

Program received signal SIG32, Real-time event 32.
0x40068bc9 in sigsuspend () from /lib/libc.so.6
(gdb) 
Continuing.

Program received signal SIG32, Real-time event 32.
0x40068bc9 in sigsuspend () from /lib/libc.so.6
(gdb) 
Continuing.

Program received signal SIG32, Real-time event 32.
0x40068bc9 in sigsuspend () from /lib/libc.so.6
(gdb) 
Continuing.
==> starting packet 2, 12582912
==> starting packet 1, 13369344
==> starting packet 3, 12845056
<== ending packet: 2

Program received signal SIG32, Real-time event 32.
0x40068bc9 in sigsuspend () from /lib/libc.so.6
(gdb) ==> starting packet 4, 14155776
<== ending packet: 1
==> starting packet 5, 14417920
<=> wasting packet 1

<snip>

<== ending packet: 15
<=> wasting packet 15
<=> wasting packet 16
Quit
(gdb) info threads
(gdb) cont
Continuing.
==> starting packet 17, 9175040
==> starting packet 19, 8650752
==> starting packet 18, 8388608
<== ending packet: 17

...

[-- Attachment #2: test.c --]
[-- Type: text/plain, Size: 977 bytes --]

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>


#include "queue.h"

typedef struct {
	long long		wait;
	int		seq;
} my_data_t;

void my_processor( void * arg_) {
	my_data_t * data = (my_data_t *)arg_;

	if ( !data) return;

	printf( "==> starting packet %d, %lld\n", data->seq, data->wait);
	fflush( stdout);
	while ( --data->wait);
	printf( "<== ending packet: %d\n", data->seq);
	fflush( stdout);
}

void my_reaper( void * arg_) {
	my_data_t * data = (my_data_t *)arg_;

	printf( "<=> wasting packet %d\n", data->seq);
	fflush( stdout);

	free( arg_);
}

int main( int argc, char ** argv) {
	queue_t * work;
	int i;

	work = queue_create( 16, 3, my_reaper);

	sleep(1);

	for ( i=1; i<50; i++) {
		my_data_t * data = (my_data_t *)malloc( sizeof( my_data_t));
		data->seq = i;
		data->wait = (long long)(50^i) << 18;

		queue_insert( work, my_processor, (void *)data);
	}

	queue_insert_last( work);
	queue_wait_last( work);
	queue_destruct( work);

	return 0;
}

[-- Attachment #3: queue.c --]
[-- Type: text/plain, Size: 4713 bytes --]

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#include "queue.h"

//#define INC( q, x)	++(x) %= (q)->_queue_size;
#define INC( q, x)	({ ++(x); (x) %= (q)->_queue_size; (x); })

//#define pthread_mutex_lock( a) { pthread_mutex_lock( a); printf( "%p: got mutex\n", pthread_self()); fflush( stdout); }

static queue_elem_t * queue_create_elem( process_func_t func_, void * data_) {
	queue_elem_t * qe = (queue_elem_t *)malloc( sizeof( queue_elem_t));
	if ( !qe) return NULL;

	qe->_data = data_;
	qe->_process = func_;
	qe->_done = 0;

	pthread_mutex_init( &qe->_elem_lock, NULL);

	return qe;
}

static queue_elem_t * queue_get_next( queue_t * q_) {
	size_t head;
	queue_elem_t * qe = NULL;
	
	pthread_mutex_lock( &q_->_queue_lock);
	while ( q_->_size != q_->_queue_size && 
			q_->_next == q_->_head && 
			!q_->_quit)
		pthread_cond_wait( &q_->_queue_insert, &q_->_queue_lock);
	if ( !q_->_quit) {
		qe = q_->_queue[ q_->_next];
		INC( q_, q_->_next);
	}
	pthread_mutex_unlock( &q_->_queue_lock);

	return qe;
}

static void * queue_worker( void * arg_) {
	queue_t * q = (queue_t *)arg_;

	while ( !q->_quit) {
		queue_elem_t * qe = queue_get_next( q);
		if ( !qe) continue;
		pthread_mutex_lock( &qe->_elem_lock);
		if ( qe->_process && qe->_data)
			qe->_process( qe->_data);
		qe->_done = 1;
		pthread_cond_signal( &q->_elem_done);
		pthread_mutex_unlock( &qe->_elem_lock);
	}

	return NULL;
}

static void * queue_reaper( void * arg_) {
	queue_t * q = (queue_t *)arg_;

	while ( !q->_quit) {
		queue_elem_t * qe = NULL;
		pthread_mutex_lock( &q->_queue_lock);
		while ( q->_tail == q->_next && !q->_quit)
			pthread_cond_wait( &q->_elem_done, &q->_queue_lock);
		if ( !q->_quit) {
			qe = q->_queue[ q->_tail];
			q->_queue[ q->_tail] = NULL;
			INC( q, q->_tail);
			--q->_size;
			pthread_cond_signal( &q->_queue_remove);
		}
		pthread_mutex_unlock( &q->_queue_lock);
		if ( !qe) continue;

		// XXX: should sync if _elem_done was not tail elem.
		pthread_mutex_lock( &qe->_elem_lock);
		assert( qe->_done);
		if ( !qe->_process && !qe->_data) q->_last = 1;
		else q->_reap( qe->_data);
		pthread_mutex_unlock( &qe->_elem_lock);
	}

	return NULL;
}

void queue_insert( queue_t * q_, process_func_t func_, void * data_) {
	size_t head;
	queue_elem_t * qe = queue_create_elem( func_, data_);
	if ( !qe) return;

	pthread_mutex_lock( &q_->_queue_lock);
	while ( q_->_size && q_->_tail == q_->_head && !q_->_quit)
		pthread_cond_wait( &q_->_queue_remove, &q_->_queue_lock);
	if ( !q_->_quit) {
		q_->_last = 0;
		assert( q_->_queue[ q_->_head] == NULL);
		q_->_queue[ q_->_head] = qe;
		INC( q_, q_->_head);
		++q_->_size;
		pthread_cond_signal( &q_->_queue_insert);
	}
	pthread_mutex_unlock( &q_->_queue_lock);
}

void queue_insert_last( queue_t * q_) {
	queue_insert( q_, NULL, NULL);
}

void queue_wait_last( queue_t * q_) {
	pthread_mutex_lock( &q_->_queue_lock);
	while ( !q_->_last)
		pthread_cond_wait( &q_->_queue_remove, &q_->_queue_lock);
	pthread_mutex_unlock( &q_->_queue_lock);
}

queue_t * queue_create( size_t queue_size_, size_t workers_, process_func_t reaper_) {
	queue_t * q;
	int i;
	int rc;

	if ( workers_ < 1 || queue_size_ < workers_ || !reaper_)
		return NULL;

	q = (queue_t *)malloc( sizeof( queue_t));
	if ( !q) return NULL;
	
	q->_queue_size = queue_size_;
	q->_queue = (queue_elem_t **)malloc( queue_size_ * sizeof( queue_elem_t *));
	if ( !q->_queue) {
		free( q);
		return NULL;
	}
	for ( i=0; i<queue_size_; i++)
		q->_queue[i] = NULL;

	q->_head = q->_tail = q->_next = q->_size = 0;

	q->_quit = 0;
	q->_reap = reaper_;
	q->_last = 0;

	pthread_mutex_init( &q->_queue_lock, NULL);
	pthread_cond_init( &q->_queue_insert, NULL);
	pthread_cond_init( &q->_queue_remove, NULL);
	pthread_cond_init( &q->_elem_done, NULL);

	q->_workers = workers_;
	q->_tid_workers = (pthread_t *)malloc( workers_ * sizeof( pthread_t));
	if ( !q->_tid_workers) {
		free( q->_queue);
		free( q);
		return NULL;
	}

	pthread_mutex_lock( &q->_queue_lock);
	for ( i=0; i<workers_; i++)
		pthread_create( &q->_tid_workers[i], NULL, queue_worker, (void *)q);

	pthread_create( &q->_tid_reaper, NULL, queue_reaper, (void *)q);
	pthread_mutex_unlock( &q->_queue_lock);

	return q;
}

void queue_destruct( queue_t * q_) {
	int i;
	
	q_->_quit = 1;
	
	for ( i=0; i<q_->_workers; i++) {
		pthread_cond_broadcast( &q_->_queue_insert);
		pthread_join( q_->_tid_workers[i], NULL);
	}

	pthread_cond_signal( &q_->_elem_done);
	pthread_join( q_->_tid_reaper, NULL);

	pthread_mutex_destroy( &q_->_queue_lock);
	pthread_cond_destroy( &q_->_queue_insert);
	pthread_cond_destroy( &q_->_queue_remove);
	pthread_cond_destroy( &q_->_elem_done);
	
	free( q_->_tid_workers);
	free( q_->_queue);
	free( q_);
}

[-- Attachment #4: queue.h --]
[-- Type: text/plain, Size: 1510 bytes --]

#ifndef __QUEUE_INCLUDED
#define __QUEUE_INCLUDED

#include <pthread.h>

typedef void (*process_func_t)( void *);

typedef struct {
	void *			_data;
	process_func_t	_process;
	volatile int	_done;

	pthread_mutex_t	_elem_lock;
} queue_elem_t;

typedef struct {
	size_t			_queue_size;
	queue_elem_t **	_queue;
	volatile size_t	_head, _tail, _next, _size;

	volatile int	_quit;
	process_func_t	_reap;
	volatile int	_last;

	pthread_mutex_t	_queue_lock;
	pthread_cond_t	_queue_insert, _queue_remove;
	pthread_cond_t	_elem_done;

	size_t			_workers;
	pthread_t *		_tid_workers;
	pthread_t		_tid_reaper;
} queue_t;

/*
	queue_insert( queue_t *, process_func_t func, void * data) 
		inserts a job into the queue; executes: func( data)
*/
void queue_insert( queue_t *, process_func_t, void *);

/*
	queue_insert_last( queue_t *); same as queue_insert( queue_t *, NULL, NULL)
*/
void queue_insert_last( queue_t *);

/*
	queue_wait_last( queue_t *)
		waits for a (NULL,NULL) job to be processed

	XXX: queue_insert resets the last flag; 
*/
void queue_wait_last( queue_t *);

/*
	queue_create( size_t queue_size, size_t workers, process_func_t reaper)
	
	creates a queue of size #queue_size with #workers workers
	and calls reaper( job.data) for each enqueued job when done
	and in sequence

	returns: queue_t * on success; NULL on error;
*/
queue_t * queue_create( size_t, size_t, process_func_t);

/*
	queue_destruct( queue_t *)

	frees resources allocated by queue_create;
*/
void queue_destruct( queue_t *);

#endif