August 2002 - Boost-users - lists.preview.boost.org

BGL: Loops in undirected graph
by Tarjei Knapstad 19 Aug '02

19 Aug '02

Is there any "standard best way" of detecting loops in an undirected graph? I had a look at chapter 4.2 in the book (which does an implementation for bidirectional graphs), and tried to adapt this implementation, but with no particular luck :) The graph I've set up in my test suite looks like this (I hope my mail prog. doesn't screw up the formatting) H15 | H8 C2 \ / \ H9-C0-C1 C3-O7-H14 / | | H10 C6 C4 / \ / \ H11 C5 H13 | H12 I'm working with molecules, so the letters denote the type of atom, but that's of no importance here. The numbers are the vertex descriptors. What I'm trying to create is an algorithm that will return the set of vertices [1, 2, 3, 4, 5, 6] defining. Now, my first step is (exactly like in the book) to record every back edge in the graph. As my graph is undirected, and there is allways a path from any one vertex to any other vertex, I thought I could just do a DFS from the first vertex in any such graph and record the back edges. In the above example, starting from 'C0', I'd expect the set of back edges obtained from a DFS to be 1-2, 2-3, 3-4, 4-5, 5-6 and 6-1, a total of 6 edges. The actual result obtained however also includes the following edges: 1-0, 11-6, 12-5, 13-4, 7-3, 14-7, 15-2, 8-0, 9-0 and 10-0. Why is this? I'm assuming there's something I missed out on, regarding graph theory and how the basic DFS works, but I cannot see any logic in this. If so, how could I modify my DFS visitor to record the (in my problem domain) "correct" back edges? This problem also gives me further trouble when trying to detect which vertices are part of each cycle. Does any of you have any suggestion for an effective implementation of the "find vertices that are part of each cycle" part of the algorithm? Any help appreciated. Cheers, -- Tarjei Knapstad

2 4

boost::function/bind Usage Again
by Albrecht Fritzsche 19 Aug '02

19 Aug '02

Here I want to extend simple callbacks so that these callbacks take an argument void fun(int i) { std::cout << "Hi fun " << i << std::endl; } struct Foo { void bar(int i) { std::cout << "Hi bar " << i << std::endl; } }; template <class Value> struct CallFunction { CallFunction(const Value& v) : mValue(value) {} // defined outside void operator()(const boost::function<void, Value>& fun) { if (fun) fun(mValue); } const Value& mValue; }; int main() { std::vector< boost::function<void, int> > funs; Foo foo; funs.push_back(&fun); funs.push_back(boost::bind(&Foo::bar, &foo, _1)); ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ int value = 7; std::for_each(funs.begin(), funs.end(), CallFunction<int>(value)); return 0; } Is this the right usage of the /_1/ here? This code runs (at least on my machine:-), but I'm quite unsure about this place holder. And since the online docu... Ah, now I see - in the online doc there are some links missing. In the files section not only the bind_template.hpp link refers to that very file but also the arg.hpp and placeholders.hpp links and many more. Having checked now the sources makes not everything clear, but at least clearer. So, I would be happy if anyone could let me know if my usage includes some misuse etc... Thanks Ali

3 2

Using gcc's typeof and boost.lambda together.
by Matthew Dempsky 19 Aug '02

19 Aug '02

I was just playing around with the boost.lambda library and thought of playing a bit with it using gcc's typeof extension... this is the code I used (just slightly modified documentation code): typedef typeof(_1 = 1) assign_one; list<int> v(10); for_each(v.begin(), v.end(), assign_one()); I was hoping it would work the same as the documentation's code, but instead it generates a few big errors about lambda_functor_base<...>::lambda_functor_base() not existing. I know typeof is a gnu extension and it's not really portable to use it in code, but does anyone have any ideas of how to get something like this to work correctly? -jivera

2 1

bug in regex 3.31 (boost 1.28)?
by emarkp 19 Aug '02

19 Aug '02

I sent this originally to James Maddock, but realized this is probably a better place to post it. At work we've been testing out regex (nice work BTW) in some of our code, and appear to have found a bug. We ran into it parsing HTML, and I've written a test C++ app to reproduce it. In the program below, the output should be the same for both searches as far as I can tell, but it's not. I don't know if it's some interaction with the quote character or something like that. We attempted to use other quantifiers (after '?', we tried '*', '{0,1}', ["]?) to no avail. I'm confident this is not user error. The extra grouping is annoying (in "goodPatternStr"), but is an acceptable workaround. The strange thing is that a non-capturing group doesn't fix it. Ideas? --Mark Ping -------------------------------------------------------------------------------------- output: input: <input type="hidden" name="MfcISAPICommand" value="SellYourItem" badOut :<input type="hidden" name="MfcISAPICommand" value="SellYourItem badOutName : badOutValue:SellYourItem goodOut :<input type="hidden" name="MfcISAPICommand" value="SellYourItem goodOutName :MfcISAPICommand goodOutValue:SellYourItem Press any key to continue -------------------------------------------------------------------------------------- #include <iostream> #include <string> #include <boost/regex.hpp> using namespace boost; using namespace std; int main() { const char* badPatternStr = "<input[^>]*name=\"?([^> \"]*)[^>]*value=\"?([^> \"]*)"; const char* goodPatternStr = "<input[^>]*name=(\"?)([^> \"]*)[^>]*value=\"?([^> \"]*)"; // ^^^^^ //note that the only difference between bad and good is that "good" //has grouping around the optional " after 'name=' // //In both versions of the matches, the second group is matched. //Only the first group has this problem. boost::match_results<std::string::const_iterator> what; std::string in = "<input type=\"hidden\" name=\"MfcISAPICommand\" value=\"SellYourItem\""; std::string::const_iterator start, end; start = in.begin(); end = in.end(); unsigned int flags = boost::match_default; std::string badOut, badOutName, badOutValue; if(regex_search(start, end, what, regex(badPatternStr), flags)) { badOut = what[0]; int numGroups = what.size(); // name badOutName = what[1]; badOutValue = what[2]; } std::string goodOut, goodOutName, goodOutValue; if(regex_search(start, end, what, regex(goodPatternStr), flags)) { goodOut = what[0]; int numGroups = what.size(); // name goodOutName = what[2]; goodOutValue = what[3]; } cout << "input: "; cout << in << endl << endl; cout << "badOut :" << badOut << endl; cout << "badOutName :" << badOutName << endl; cout << "badOutValue:" << badOutValue << endl; cout << endl; cout << "goodOut :" << goodOut << endl; cout << "goodOutName :" << goodOutName << endl; cout << "goodOutValue:" << goodOutValue << endl; return 0; }

2 5

RE: [Boost-Users] detail/lightweight_mutex.hpp
by Tom Matelich 17 Aug '02

17 Aug '02

> From: Tom Matelich [mailto:tmatelich@zetec.com] > > From: Peter Dimov [mailto:pdimov@mmltd.net] > > From: "Tom Matelich" <tmatelich(a)zetec.com> > > > I'm attempting to go to Boost 1.28 on our HPUX 10.20 boxes. > > I've run into > > a > > > problem with an assumption about the type of pthread_mutexattr_t. > > > detail\lwm_pthreads.hpp calls: > > > > > > pthread_mutex_init(&m_, 0); > > > > > > HP's pthread.h (10.20 uses DCE) has that defined as: > > > > > > int pthread_mutex_init (pthread_mutex_t *,pthread_mutexattr_t); > > > > I don't know what to do about it. My POSIX draft says > > > > int pthread_mutex_init(pthread_mutex_t *restrict mutex, const > > pthread_mutexattr_t *restrict attr); > > > > and goes on to specify that 0/NULL for the second argument > > causes default > > attributes to be used. > > > > I know little - if anything - about HPUX 10.20; if you find a > > solution let > > me know, and I'll incorporate it into lwm_pthreads.hpp. Sorry. > > > > The dce documentation I see says to use pthread_mutexattr_default. > http://www.transarc.ibm.com/Library/documentation/dce/1.1/pthread_mutex_init .html > >So, it looks like I need to find a version to if or ifdef off of. I found a define in dce/cma.h (appended to my original email) which seems to fit the bill: /* * Define a symbol which client code can test to determine whether the * underlying threads package is DECthreads or not. This is especially * important to clients of the Pthreads interface who may want to use * certain DECthreads extensions, such as the global lock and non-real-time * scheduling policies, on the DECthreads platform while maintaining * portability to a "vanilla" pthreads implementation. */ #define _DECTHREADS_ 1 Although, I'm not sure how to find out if this should be used generally, or only on HP. ----------------------------------------------------------------------- DISCLAIMER: Information contained in this message and/or attachment(s) may contain confidential information of Zetec, Inc. If you have received this transmission in error, please notify the sender by return email. -----------------------------------------------------------------------

2 1

regex performance
by Paul Dubuc 17 Aug '02

17 Aug '02

I'm doing some performance comparisons between Rogue Wave's Regexp class (http://www.roguewave.com/support/docs/tlsref/rwcregexp.cfm) and boost::regex using simple expressions like "^metal.*" and "[0-9]+" with regex_search(). regex is slower by a factor of 6, measuring cpu time (on a SunBlade 100 runing Solaris 8). Is there anything I can do to speed it up? I tried using different values of boost::regbase::flag_type_ to adjust how the regular expressions are interpreted, but with little effect. Any other ideas? (I'm using boost_1_27_0.) Thanks, -- Paul M. Dubuc

7 12

request for comment on possible submission to library
by DrXenos 17 Aug '02

17 Aug '02

I was wondering if anyone would be interested in a Set Library, similar to Pascal's set type for ordinal types. I want to make sure someone would fine it useful (and not trivial, done-to-death, etc.) before I take the time to "Boostify" it and get a release from my employer. A while ago I needed a set type that was compact, fast, and avoided heap allocation. The number of elements was constant for a particular set type, and the element type could be any integral type (primarily enums). Similar types from STL are set, vector<bool>, and bitset, but none quite suited the application. My set type (Set) stores elements at the bit level, like vector<bool> and bitset, but it allows the creation of compile-time set constants. Also, with a good optimizing compiler, operations on constant sets will be done at compile-time, though as of yet, there is no direct support for guaranteeing this in the code. The class provides the usual set operations. For efficiency, set operations are done in parallel groups of the machine's word size. So, set types whose max. number of elements is less than or equal to the machine's word size, will have most of its operations done in constant time (usually one machine instruction per operation). Sets whose max. number of elements is greater than the machine's word size will be done in linear time, usually in E / Wb cycles, where E is the max. number of elements and Wb is the machine's word size in bits. Though, with a good compile (through inlining and loop unrolling), this linear time would only be E / Wb instructions. On an average 32-bit processor, that's just 8 instructions to perform the union or intersection of a set of 256 elements. Originally, I avoided loops and used metatemplates to inline the operations, but this resulted in very long compile-times without any gains in performance! And sometimes it resulted in worse performance. That will teach me not to try and second guess today's optimizing compilers! As I stated above, the class template may be instantiated with any integral type, but it was primarily meant for enumerations with will give you the added bonuses of type-safely and symbolic names for the elements. The class assumes that the range given is not disjoint (i.e., 0-63 and not 0 - 16, 19, 63). You may use disjoint ranges, but your sets will contain wasted space. The only requirement is that the range of values is greater than or equal to zero, and that the element type has a representation for -1 (used as a (hidden) sentinel in argument lists of elements). You could even conceivably use a class that was "castable" to int. For example: // element type enum Color {red, orange, yellow, green, blue, violet, NumColors, NilColor = -1}; // type for set of colors typedef Set<Color, NumColors> ColorSet; // set constant const ColorSet rgb = ColorSet::SetOf<red, green, blue>::value(); // this is done at compile-time void foo() { // construction ColorSet s = ColorSet::SetOf<orange, yellow, violet>::value(); // this is done at compile-time ColorSet s1 = ColorSet(a); // this *may* be at compile-time ColorSet s2 = ColorSet(orange, yellow, violet); // this is NOT done at compile-time // (but allows non-constant elements) // operations, some of which *may* be done at compile-time by a smart compiler ColorSet a = s; // assignment ColorSet b = s + rgb; // union ColorSet c = s * rgb; // intersection ColorSet d = s - rgb; // difference ColorSet e = s / rgb; // symmetric difference bool b1 = s == rgb; // equality bool b1 = s != rgb; // unequality bool b3 = s >= rgb; // superset bool b4 = s > rgb; // proper superset bool b5 = s < rgb; // subset bool b6 = s > rgb; // proper subset if (b.contains(red)) // test for set membership std::cout << "b contains the element red" << std::endl; if (red == b) // same as above. can anyone suggest a better operator? // maybe use red -> b and use NULL for false? // or maybe remove and just use b.contains(red)? std::cout << "b contains the element red" << std::endl; } What do you think? Thanks, Rich (spamjunk(a)stny.rr.com)

1 0

RE: [Boost-Users] detail/lightweight_mutex.hpp
by Tom Matelich 16 Aug '02

16 Aug '02

> From: Peter Dimov [mailto:pdimov@mmltd.net] > > From: "Tom Matelich" <tmatelich(a)zetec.com> > > I'm attempting to go to Boost 1.28 on our HPUX 10.20 boxes. > I've run into > a > > problem with an assumption about the type of pthread_mutexattr_t. > > detail\lwm_pthreads.hpp calls: > > > > pthread_mutex_init(&m_, 0); > > > > HP's pthread.h (10.20 uses DCE) has that defined as: > > > > int pthread_mutex_init (pthread_mutex_t *,pthread_mutexattr_t); > > I don't know what to do about it. My POSIX draft says > > int pthread_mutex_init(pthread_mutex_t *restrict mutex, const > pthread_mutexattr_t *restrict attr); > > and goes on to specify that 0/NULL for the second argument > causes default > attributes to be used. > > I know little - if anything - about HPUX 10.20; if you find a > solution let > me know, and I'll incorporate it into lwm_pthreads.hpp. Sorry. > The dce documentation I see says to use pthread_mutexattr_default. http://www.transarc.ibm.com/Library/documentation/dce/1.1/pthread_mutex_init .html So, it looks like I need to find a version to if or ifdef off of. ----------------------------------------------------------------------- DISCLAIMER: Information contained in this message and/or attachment(s) may contain confidential information of Zetec, Inc. If you have received this transmission in error, please notify the sender by return email. -----------------------------------------------------------------------

1 0

detail/lightweight_mutex.hpp
by Tom Matelich 16 Aug '02

16 Aug '02

I'm attempting to go to Boost 1.28 on our HPUX 10.20 boxes. I've run into a problem with an assumption about the type of pthread_mutexattr_t. detail\lwm_pthreads.hpp calls: pthread_mutex_init(&m_, 0); HP's pthread.h (10.20 uses DCE) has that defined as: int pthread_mutex_init (pthread_mutex_t *,pthread_mutexattr_t); after tracing the typedef's down to <dce/cma.h>, I found pthread_mutexattr_t is this: typedef struct CMA_T_HANDLE { cma_t_address field1; short int field2; short int field3; } cma_t_handle; where cma_t_address is a void*. The error message is: .../boost/detail/lwm_pthreads.hpp: In method `boost::detail::lightweight_mutex::lightweight_mutex()': .../boost/detail/lwm_pthreads.hpp:40: conversion from `int' to non-scalar type `CMA_T_HANDLE' requested I'm not sure what solution to use here. Ifdefs are troublesome because it is hard to distinguish between HP 10.x and 11.x, which use different threading models. I don't know a lot about threads on HP, we use ACE so that we don't have to. One thing I do remember is that they conform to a fairly old revision of POSIX. I think attachments are prohibited on this list, so I will append pthread.h and dce/cma.h below. Thanks for your help, Tom <"pthread.h"> /* * (c) Copyright 1990, 1991, 1992, 1993 OPEN SOFTWARE FOUNDATION, INC. * ALL RIGHTS RESERVED * COPYRIGHT NOTICE * Copyright (c) 1990, 1991, 1992, 1993, 1994 Open Software Foundation, Inc. * ALL RIGHTS RESERVED (DCE). See the file named COPYRIGHT.DCE for * the full copyright text. */ /* * @(#)HP DCE/9000 1.5 * @(#)Module: pthread.h $Revision: /main/HPDCE02/5 $ $Date: 1995/07/11 17:25 UTC $ */ /* */ /* * %W% (DEC OSF/1) %G% */ /* * Copyright (c) 1990, 1992 by * Digital Equipment Corporation, Maynard Massachusetts. * All rights reserved. * * This software is furnished under a license and may be used and copied * only in accordance with the terms of such license and with the * inclusion of the above copyright notice. This software or any other * copies thereof may not be provided or otherwise made available to any * other person. No title to and ownership of the software is hereby * transferred. * * The information in this software is subject to change without notice * and should not be construed as a commitment by DIGITAL Equipment * Corporation. * * DIGITAL assumes no responsibility for the use or reliability of its * software on equipment which is not supplied by DIGITAL. */ /* * FACILITY: * * Common Multithread Architecture (CMA) services; POSIX 1003.4 interface * * ABSTRACT: * * External definitions for CMA's pthreads services * * AUTHORS: * * Dave Butenhof * * CREATION DATE: * * 20 February 1990 * * MODIFIED BY: * * Dave Butenhof * Paul Curtin * Webb Scales */ #ifndef PTHREAD #define PTHREAD #if !defined(__STDC__) && defined(_CMA_HP_INT_NONANSI) # include <dce/pthread_int.h> #else #ifdef vms # include <cma.h> #else# include <dce/cma.h> # include <signal.h> #endif #ifdef __cplusplus extern "C" { #endif /* * The implementation makes these basic decisions */ #ifndef _POSIX_THREADS # define _POSIX_THREADS #endif#ifndef _POSIX_THREAD_ATTR_STACKSIZE # define _POSIX_THREAD_ATTR_STACKSIZE #endif#if _CMA_KTHREADS_ != _CMA__MACH # define _POSIX_THREADS_REALTIME_SCHEDULING 1 #else#if defined (_POSIX_THREADS_REALTIME_SCHEDULING) # undef _POSIX_THREADS_REALTIME_SCHEDULING #endif#endif#ifndef _POSIX_THREADS_PER_PROCESS_SIGNALS_1 # define _POSIX_THREADS_PER_PROCESS_SIGNALS_1 1 #endif /* * Implement push and pop for cancellation handlers, using TRY and ENDTRY */ #define pthread_cleanup_push(routine,arg) \ { \ pthread_cleanup_t _XXX_proc = (pthread_cleanup_t)(routine); \ pthread_addr_t _XXX_arg = (arg); \ int _XXX_completed = 0; \ TRY { #define pthread_cleanup_pop(execute) \ _XXX_completed = 1;} \ FINALLY { \ int _XXX_execute = execute; \ if ((! _XXX_completed) || (_XXX_execute)) _XXX_proc (_XXX_arg);} \ ENDTRY} #define pthread_equal_np(thread1,thread2) \ (((thread1).field1 == (thread2).field1) \ && ((thread1).field2 == (thread2).field2) \ && ((thread1).field3 == (thread2).field3)) #define pthread_equal(thread1,thread2) \ (((thread1).field1 == (thread2).field1) \ && ((thread1).field2 == (thread2).field2) \ && ((thread1).field3 == (thread2).field3)) #define pthread_getunique_np(handle) \ ((unsigned int)((pthread_t *)handle)->field2) /* * Sample decisions for the environment types */ typedef cma_t_key pthread_key_t; typedef cma_t_address pthread_addr_t; /* * For compatibility with OSF/1 pthreads */ typedef pthread_addr_t any_t; typedef void (*pthread_cleanup_t) (pthread_addr_t); /* * Sample decision for a one-time initialization control block and its * initialization macro. * * Declare a one time initialization control block as: * * static pthread_once_t block = pthread_once_init; */ typedef cma_t_once pthread_once_t; #define pthread_once_init cma_once_init #define CANCEL_ON 1 #define CANCEL_OFF 0 /* * The following are the portable pthread definitions */ /* * Operations on Handles */ /* * Operations on attributes objects */ typedef cma_t_attr pthread_attr_t; /* * An attributes object is created to specify the attributes of other CMA * objects that will be created. */ int pthread_attr_create (pthread_attr_t *); /* * An attributes object can be deleted when it is no longer needed. */ int pthread_attr_delete (pthread_attr_t *); /* * Operations on threads */ typedef cma_t_thread pthread_t; typedef cma_t_start_routine pthread_startroutine_t; /* * For compatibility with OSF/1 pthreads */ typedef pthread_startroutine_t pthread_func_t; #define PTHREAD_INHERIT_SCHED ((int)cma_c_sched_inherit) #define PTHREAD_DEFAULT_SCHED ((int)cma_c_sched_use_default) #define SCHED_FIFO ((int)cma_c_sched_fifo) #define SCHED_RR ((int)cma_c_sched_rr) #define SCHED_FG_NP ((int)cma_c_sched_throughput) #define SCHED_BG_NP ((int)cma_c_sched_background) /* For compatibility with namespace collision due to POSIX.4 includes */ #ifndef _SYS_SCHED_INCLUDED # define SCHED_OTHER ((int)cma_c_sched_throughput) #endif #define PRI_FIFO_MIN ((int)cma_c_prio_fifo_min) #define PRI_FIFO_MAX ((int)cma_c_prio_fifo_max) #define PRI_RR_MIN ((int)cma_c_prio_rr_min) #define PRI_RR_MAX ((int)cma_c_prio_rr_max) #define PRI_FG_MIN_NP ((int)cma_c_prio_through_min) #define PRI_FG_MAX_NP ((int)cma_c_prio_through_max) #define PRI_BG_MIN_NP ((int)cma_c_prio_back_min) #define PRI_BG_MAX_NP ((int)cma_c_prio_back_max) #define PRI_OTHER_MIN ((int)cma_c_prio_through_min) #define PRI_OTHER_MAX ((int)cma_c_prio_through_max) /* * Operations to define thread creation attributes */ /* * Set or obtain the default thread priority. */ int pthread_attr_setprio (pthread_attr_t *,int); int pthread_attr_getprio (pthread_attr_t); /* * Set or obtain the default scheduling algorithm */ int pthread_attr_setsched (pthread_attr_t *,int); int pthread_attr_getsched (pthread_attr_t); /* * Set or obtain whether a thread will use the default scheduling attributes, * or inherit them from the creating thread. */ int pthread_attr_setinheritsched (pthread_attr_t *,int); int pthread_attr_getinheritsched (pthread_attr_t); /* * Set or obtain the default stack size */ int pthread_attr_setstacksize (pthread_attr_t *,long); long pthread_attr_getstacksize (pthread_attr_t); /* * Set or obtain the default guard size */ int pthread_attr_setguardsize_np (pthread_attr_t *,long); long pthread_attr_getguardsize_np (pthread_attr_t); /* * The following procedures can be used to control thread creation, * termination and deletion. */ /* * To create a thread object and runnable thread, a routine must be specified * as the new thread's start routine. An argument may be passed to this * routine, as an untyped address; an untyped address may also be returned as * the routine's value. An attributes object may be used to specify details * about the kind of thread being created. */ int pthread_create (pthread_t *,pthread_attr_t,pthread_startroutine_t,pthread_addr_t); /* * A thread object may be "detached" to specify that the return value and * completion status will not be requested. */ int pthread_detach (pthread_t *); /* * A thread may terminate it's own execution. */ void pthread_exit (pthread_addr_t); /* * A thread can await termination of another thread and retrieve the return * value of the thread. */ int pthread_join (pthread_t,pthread_addr_t *); /* * Thread Scheduling Operations */ /* * The current user_assigned priority of a thread can be changed. */ int pthread_setprio (pthread_t,int); /* * The current user_assigned scheduler algorithm of a thread can be changed. */ int pthread_setscheduler (pthread_t,int,int); /* * A thread may tell the scheduler that its processor can be made available. */ void pthread_yield (void); /* * Thread Information Operations */ /* * A thread may obtain a copy of its own thread handle. */ pthread_t pthread_self (void); /* * The current user_assigned priority of a thread can be read. */ int pthread_getprio (pthread_t); /* * The current user_assigned scheduler algorithm of a thread can be read. */ int pthread_getscheduler ( pthread_t); /* * Operations on Mutexes */ #define MUTEX_FAST_NP 0 #define MUTEX_RECURSIVE_NP 1 #define MUTEX_NONRECURSIVE_NP 2 typedef cma_t_attr pthread_mutexattr_t; typedef cma_t_mutex pthread_mutex_t; int pthread_mutexattr_create (pthread_mutexattr_t *); int pthread_mutexattr_delete (pthread_mutexattr_t *); int pthread_mutexattr_setkind_np (pthread_mutexattr_t *,int); int pthread_mutexattr_getkind_np (pthread_mutexattr_t); /* * The following routines create, delete, lock and unlock mutexes. */ int pthread_mutex_init (pthread_mutex_t *,pthread_mutexattr_t); int pthread_mutex_destroy (pthread_mutex_t *); int pthread_mutex_lock (pthread_mutex_t *); int pthread_mutex_trylock (pthread_mutex_t *); int pthread_mutex_unlock (pthread_mutex_t *); /* * Operations on condition variables */ typedef cma_t_attr pthread_condattr_t; typedef cma_t_cond pthread_cond_t; int pthread_condattr_create (pthread_condattr_t *); int pthread_condattr_delete (pthread_condattr_t *); /* * A thread can create and delete condition variables. */ int pthread_cond_init (pthread_cond_t *,pthread_condattr_t); int pthread_cond_destroy (pthread_cond_t *); /* * A thread can signal to and broadcast on a condition variable. */ int pthread_cond_broadcast (pthread_cond_t *); int pthread_cond_signal (pthread_cond_t *); int pthread_cond_signal_int_np (pthread_cond_t *); /* * A thread can wait for a condition variable to be signalled or broadcast. */ int pthread_cond_wait (pthread_cond_t *,pthread_mutex_t *); /* * Operations for timed waiting */ /* * A thread can perform a timed wait on a condition variable. */ int pthread_cond_timedwait (pthread_cond_t *,pthread_mutex_t *,struct timespec *); /* * Operations for client initialization. */ typedef void (*pthread_initroutine_t) (void); int pthread_once (pthread_once_t *,pthread_initroutine_t); /* * Operations for per-thread context */ typedef cma_t_destructor pthread_destructor_t; /* * A unique per-thread context key can be obtained for the process */ int pthread_keycreate (pthread_key_t *,pthread_destructor_t); /* * A thread can set a per-thread context value identified by a key. */ int pthread_setspecific (pthread_key_t,pthread_addr_t); /* * A thread can retrieve a per-thread context value identified by a key. */ int pthread_getspecific (pthread_key_t,pthread_addr_t *); /* * Operations for alerts. */ /* * The current thread can request that a thread terminate it's execution. */ int pthread_cancel (pthread_t); /* * The current thread can poll for alert delivery. */ void pthread_testcancel (void); /* * The current thread can enable or disable alert delivery (PTHREAD * "cancels"); it can control "general cancelability" (CMA "defer") or * just "asynchronous cancelability" (CMA "asynch disable"). */ int pthread_setasynccancel (int); int pthread_setcancel (int); _CMA_IMPORT_ pthread_attr_t pthread_attr_default; _CMA_IMPORT_ pthread_mutexattr_t pthread_mutexattr_default; _CMA_IMPORT_ pthread_condattr_t pthread_condattr_default; /* * Define nonportable extensions */ extern int pthread_get_expiration_np (struct timespec *,struct timespec *); extern int pthread_delay_np (struct timespec *); #if (_CMA_UNIX_TYPE == _CMA__SVR4) extern unsigned int pthread_delay_unsigned_np (unsigned int ); #endif /* (_CMA_UNIX_TYPE == _CMA__SVR4) */ extern void pthread_lock_global_np (void); extern void pthread_unlock_global_np (void); # if _CMA_OS_ != _CMA__VMS extern int pthread_signal_to_cancel_np (sigset_t *,pthread_t *); # endif #ifdef __hpux extern int pthread_is_multithreaded_np (void); #endif #ifdef __cplusplus } #endif #endif /* _CMA_HP_INT_NONANSI */ #endif </"pthread.h"> <"dce/cma.h"> /* * (c) Copyright 1990, 1991, 1992, 1993 OPEN SOFTWARE FOUNDATION, INC. * ALL RIGHTS RESERVED * COPYRIGHT NOTICE * Copyright (c) 1990, 1991, 1992, 1993, 1994 Open Software Foundation, Inc. * ALL RIGHTS RESERVED (DCE). See the file named COPYRIGHT.DCE for * the full copyright text. * * (c) Copyright 1991, 1992 Siemens-Nixdorf Information Systems * Burlington, MA, USA */ /* * @(#)HP DCE/9000 1.5 * @(#)Module: cma.h $Revision: /main/HPDCE02/3 $ $Date: 1995/09/07 19:35 UTC $ */ /* */ /* * %W% (DEC OSF/1) %G% */ /* * Copyright (c) 1988, 1992 by * Digital Equipment Corporation, Maynard Massachusetts. * All rights reserved. * * This software is furnished under a license and may be used and copied * only in accordance with the terms of such license and with the * inclusion of the above copyright notice. This software or any other * copies thereof may not be provided or otherwise made available to any * other person. No title to and ownership of the software is hereby * transferred. * * The information in this software is subject to change without notice * and should not be construed as a commitment by DIGITAL Equipment * Corporation. * * DIGITAL assumes no responsibility for the use or reliability of its * software on equipment which is not supplied by DIGITAL. */ /* * FACILITY: * * Digital's Proprietary Interface to DECthreads (CMA) * * ABSTRACT: * * External definitions for CMA services * * AUTHORS: * * Dave Butenhof * * CREATION DATE: * * 2 November 1988 * * MODIFIED BY: * * Dave Butenhof * Bob Conti * Paul Curtin * Hans Oser * Webb Scales */ #ifndef CMA_INCLUDE #define CMA_INCLUDE /* * Define a symbol which client code can test to determine whether the * underlying threads package is DECthreads or not. This is especially * important to clients of the Pthreads interface who may want to use * certain DECthreads extensions, such as the global lock and non-real-time * scheduling policies, on the DECthreads platform while maintaining * portability to a "vanilla" pthreads implementation. */ #define _DECTHREADS_ 1 /* * The implementation makes these basic decisions */ #if defined(vms) || defined(__vms) || defined (VMS) || defined(__VMS) || defined(__vms__) # include <cma_config.h> /* configuration symbols */ #else# include <dce/cma_config.h> /* configuration symbols */ #endif /* For HP_UX, specifies which version of the operating system we are building on */ #if _CMA_VENDOR_ == _CMA__HP # include <dce/hpdce_platform.h> #endif /* Fix ordering problem with "wait" definition in HP-UX 1010 header files */ #if defined(__hpux1010p) # define wait cma_wait #endif #if (_CMA_UNIX_TYPE == _CMA__SVR4) && (_CMA_REENTRANT_CLIB_) # if defined _libcma_code_ # include <cma_libc_redefs.h> # endif#endif #if _CMA_OS_ != _CMA__VMS # include <sys/types.h> # include <sys/time.h> #endif #if _CMA_OS_ == _CMA__VMS # include <exc_handling.h> /* Bring in exception services */ #else# include <dce/exc_handling.h> /* Bring in exception services */ #endif #if (_CMA_OSIMPL_ == _CMA__OS_OSF) && _CMA_REENTRANT_CLIB_ # define _REENTRANT 1 /* Enable reentrant errno.h */ #endif #if (_CMA_VENDOR_ == _CMA__HP) && _CMA_REENTRANT_CLIB_ # ifndef _REENTRANT # define _REENTRANT 1 # endif#endif #ifdef __cplusplus extern "C" { #endif /* * Sample decisions for the environment types */ typedef int cma_t_integer; typedef unsigned int cma_t_boolean; typedef unsigned int cma_t_natural; typedef float cma_t_interval; typedef int cma_t_key; typedef int cma_t_status; typedef int cma_t_priority; #if _CMA_VOID_ typedef void *cma_t_address; #elsetypedef char *cma_t_address; #endif #define cma_c_false (cma_t_boolean)0 #define cma_c_true (cma_t_boolean)1 #define cma_c_null_ptr (cma_t_address)0 #define cma_c_prio_fifo_min 16 #define cma_c_prio_fifo_mid 24 #define cma_c_prio_fifo_max 31 #define cma_c_prio_rr_min 16 #define cma_c_prio_rr_mid 24 #define cma_c_prio_rr_max 31 #define cma_c_prio_through_min 8 #define cma_c_prio_through_mid 12 #define cma_c_prio_through_max 15 #define cma_c_prio_back_min 1 #define cma_c_prio_back_mid 4 #define cma_c_prio_back_max 7 #define cma_c_prio_ada_low_min 0 #define cma_c_prio_ada_low_mid 4 #define cma_c_prio_ada_low_max 7 /* * The implementation of the cma_t_date_time type should match the "native * time" of the platform: that allows clients to use the full set of platform * time operations, rather than just "cma_get_expiration", to compute and * test timed waits. * * This section assumes the platform is either "VMS" or "UNIX-ish". Others * will require changes. */ #if _CMA_OS_ == _CMA__VMS typedef struct CMA_T_DATE_TIME { unsigned long int low; unsigned long int high; } cma_t_date_time; #elsetypedef struct timeval cma_t_date_time; #endif #ifdef __hpux /* * Structure for C++ callbacks */ typedef struct CB_STRUCT { void (*start)(); void (*end)(); void (*out)(); void (*in)(); } _ctxcb_spec_t; #endif /* * Sample decisions for what handles shall be */ typedef struct CMA_T_HANDLE { cma_t_address field1; short int field2; short int field3; } cma_t_handle; #define cma_thread_get_unique(handle) \ ((unsigned int)((cma_t_thread *)handle)->field2) #define cma_c_handle_size sizeof(cma_t_handle) typedef cma_t_handle cma_t_mutex; /* Needed for CMA_ONCE_BLOCK */ /* * Predefined null handle */ #ifndef _CMA_SUPPRESS_EXTERNALS_ _CMA_IMPORT_ cma_t_handle cma_c_null; #endif /* * Sample decision for a one-time initialization control block and its * initialization macro. * * Declare a one time initialization control block as: * * static cma_t_once block = cma_once_init; */ typedef struct CMA_T_ONCE { cma_t_integer field1; cma_t_integer field2; cma_t_integer field3; } cma_t_once; #define cma_once_init {0, 0, 0} /* * Sample decision for a variable to save the current alert state. */ typedef struct CMA_T_ALERT_STATE { cma_t_integer state1; cma_t_integer state2; } cma_t_alert_state; /* * The following are the portable CMA definitions */ /* * Operations on Handles */ /* * The value of a handle can be assigned the value of another handle. */ extern void cma_handle_assign (cma_t_handle *, cma_t_handle *); /* * The value of a handle can be compared to the value of another handle. */ extern cma_t_boolean cma_handle_equal ( cma_t_handle *, cma_t_handle *); /* * Operations on attributes objects */ typedef cma_t_handle cma_t_attr; /* * An attributes object is created to specify the attributes of other CMA * objects that will be created. */ extern void cma_attr_create (cma_t_attr *,cma_t_attr *); /* * An attributes object can be deleted when it is no longer needed. */ extern void cma_attr_delete (cma_t_attr *); /* * Operations on threads */ typedef cma_t_handle cma_t_thread; typedef cma_t_address (*cma_t_start_routine) (cma_t_address); typedef enum CMA_T_EXIT_STATUS { cma_c_term_error = 0, cma_c_term_normal = 1, cma_c_term_alert = 2 } cma_t_exit_status; typedef enum CMA_T_SCHED_INHERIT { cma_c_sched_inherit = 0, cma_c_sched_use_default = 1 } cma_t_sched_inherit; typedef enum CMA_T_SCHED_POLICY { cma_c_sched_fifo = 0, cma_c_sched_rr = 1, cma_c_sched_throughput = 2, cma_c_sched_background = 3, cma_c_sched_ada_low = 4 } cma_t_sched_policy; #define cma_c_sched_default cma_c_sched_throughput #define cma_c_sched_other cma_c_sched_default /* * The following procedures can be used to control thread creation, * termination and deletion. */ /* * To create a thread object and runnable thread, a routine must be specified * as the new thread's start routine. An argument may be passed to this * routine, as an untyped address; an untyped address may also be returned as * the routine's value. An attributes object may be used to specify details * about the kind of thread being created. */ extern void cma_thread_create (cma_t_thread *,cma_t_attr *,cma_t_start_routine,cma_t_address); /* * A thread object may be "detached" to specify that the return value and * completion status will not be requested. */ extern void cma_thread_detach (cma_t_thread *); /* * A thread may terminate it's own execution. */ extern void cma_thread_exit_error (void); extern void cma_thread_exit_normal (cma_t_address); /* * A thread can await termination of another thread and retrieve the return * value and completion status of the thread. */ extern void cma_thread_join (cma_t_thread *,cma_t_exit_status *,cma_t_address *); /* * Operations to define thread creation attributes */ /* * Set or obtain the default thread priority. */ extern void cma_attr_set_priority (cma_t_attr *,cma_t_priority); extern void cma_attr_get_priority (cma_t_attr *,cma_t_priority *); /* * Set or obtain the default scheduling algorithm */ extern void cma_attr_set_sched (cma_t_attr *,cma_t_sched_policy ,cma_t_priority); extern void cma_attr_get_sched (cma_t_attr *,cma_t_sched_policy *); /* * Set or obtain whether a thread will use the default scheduling attributes, * or inherit them from the creating thread. */ extern void cma_attr_set_inherit_sched (cma_t_attr *,cma_t_sched_inherit); extern void cma_attr_get_inherit_sched (cma_t_attr *,cma_t_sched_inherit *); /* * Set or obtain the default stack size */ extern void cma_attr_set_stacksize (cma_t_attr *,cma_t_natural); extern void cma_attr_get_stacksize (cma_t_attr *,cma_t_natural *); /* * Set or obtain the default guard size */ extern void cma_attr_set_guardsize (cma_t_attr *,cma_t_natural); extern void cma_attr_get_guardsize (cma_t_attr *,cma_t_natural *); /* * Thread Scheduling Operations */ /* * The current user_assigned priority of a thread can be changed. */ extern void cma_thread_set_priority (cma_t_thread *,cma_t_priority); /* * The current user_assigned scheduler algorithm of a thread can be changed. */ extern void cma_thread_set_sched (cma_t_thread *,cma_t_sched_policy,cma_t_priority); /* * A thread may tell the scheduler that its processor can be made available. */ extern void cma_yield (void); #ifndef _HP_CMA_PERF_ extern void cma_yield_noselect (void); #endif /* _HP_CMA_PERF_ */ /* * A thread may enter a wait state for a speciifed period of time. */ extern void cma_delay (cma_t_interval); /* * Thread Information Operations */ /* * A thread may obtain a copy of its own thread handle. */ extern void cma_thread_get_self (cma_t_thread *); /* * The current user_assigned priority of a thread can be read. */ extern void cma_thread_get_priority (cma_t_thread *,cma_t_priority *); /* * The current user_assigned scheduler algorithm of a thread can be read. */ extern void cma_thread_get_sched (cma_t_thread *,cma_t_sched_policy *); /* * Operations on Mutexes */ typedef enum CMA_T_MUTEX_KIND { cma_c_mutex_fast = 0, cma_c_mutex_recursive = 1, cma_c_mutex_nonrecursive = 2 } cma_t_mutex_kind; /* * Operations to define mutex creation attributes */ /* * Set or obtain whether mutex locks can nest. */ extern void cma_attr_set_mutex_kind (cma_t_attr *,cma_t_mutex_kind); extern void cma_attr_get_mutex_kind (cma_t_attr*,cma_t_mutex_kind *); /* * The following routines create, delete, lock and unlock mutexes. */ extern void cma_mutex_create (cma_t_mutex *,cma_t_attr *); extern void cma_mutex_delete (cma_t_mutex *); extern void cma_mutex_lock (cma_t_mutex *); extern cma_t_boolean cma_mutex_try_lock (cma_t_mutex *); extern void cma_mutex_unlock (cma_t_mutex *); extern void cma_lock_global (void); extern void cma_unlock_global (void); /* * Operations on condition variables */ typedef cma_t_handle cma_t_cond; /* * A thread can create and delete condition variables. */ extern void cma_cond_create (cma_t_cond *,cma_t_attr *); extern void cma_cond_delete (cma_t_cond *); /* * A thread can signal to and broadcast on a condition variable. */ extern void cma_cond_broadcast (cma_t_cond *); extern void cma_cond_signal (cma_t_cond *); extern void cma_cond_signal_int (cma_t_cond *); /* * A thread can wait for a condition variable to be signalled or broadcast. */ extern void cma_cond_wait (cma_t_cond *,cma_t_mutex *); /* * Operations for timed waiting */ /* * A thread can perform a timed wait on a condition variable. */ extern cma_t_status cma_cond_timed_wait (cma_t_cond *,cma_t_mutex *,cma_t_date_time *); /* * A thread may perform some operations on absolute date-time and intervals. */ extern void cma_time_get_expiration (cma_t_date_time *,cma_t_interval ); /* * Operations for CMA and client initialization. */ /* * Initialize the CMA facility. */ extern void cma_init (void); /* * A thread can declare a one-time initialization routine. The address of * the init block and routine are passed as parameters. */ typedef void (*cma_t_init_routine) (cma_t_address); extern void cma_once (cma_t_once *_block,cma_t_init_routine,cma_t_address); /* * Operations for per-thread context */ typedef void (*cma_t_destructor) (cma_t_address); /* * A unique per-thread context key can be obtained for the process */ extern void cma_key_create (cma_t_key *,cma_t_attr *,cma_t_destructor); /* * A thread can set a per-thread context value identified by a key. */ extern void cma_key_set_context (cma_t_key,cma_t_address); /* * A thread can retrieve a per-thread context value identified by a key. */ extern void cma_key_get_context (cma_t_key,cma_t_address *_value); /* * Operations for alerts. */ /* * The current thread can request that a thread terminate it's execution. */ extern void cma_thread_alert (cma_t_thread *); /* * The current thread can poll for alert delivery. */ extern void cma_alert_test (void); /* * The current thread can disable asynchronous alert delivery, restore the * previous state of asynchronous alert delivery, or enable asynchronous * alert delivery. */ extern void cma_alert_disable_asynch (cma_t_alert_state *); extern void cma_alert_disable_general (cma_t_alert_state *); extern void cma_alert_enable_asynch (void); extern void cma_alert_enable_general (cma_t_alert_state *); extern void cma_alert_restore (cma_t_alert_state *); /* * Operations on stacks */ typedef cma_t_handle cma_t_stack_np; typedef void (*cma_t_call_routine) (void); /* * Allocate stack space */ extern void cma_stack_allocate_np (cma_t_integer,cma_t_address *); /* * Assign a stack to a thread */ extern void cma_stack_assign_np (cma_t_stack_np *,cma_t_thread *); /* * Call a routine on a new stack */ extern void cma_stack_call_routine_np (cma_t_stack_np *,cma_t_call_routine,cma_t_address,cma_t_address *); /* * Check stack limit */ extern cma_t_boolean cma_stack_check_limit_np (cma_t_integer); /* * Create a new stack */ extern void cma_stack_create_np (cma_t_stack_np *,cma_t_attr *); /* * Delete a stack */ extern void cma_stack_delete_np (cma_t_stack_np *); /* * Debug threads */ extern void cma_debug (void); extern void cma_debug_cmd (char *, ...); #ifndef _CMA_SUPPRESS_EXTERNALS_ _CMA_IMPORT_ void (*cma_g_debug) (void); #endif #ifdef __cplusplus } #endif # if defined(_HP_LIBC_R) && defined(__hpux1010p) # define sigaction _sigaction_sys # endif # if _CMA_OS_ == _CMA__VMS # include <cma_px.h> # else# include <dce/cma_px.h> # endif #if _CMA_UNIPROCESSOR_ # if _CMA_OS_ == _CMA__VMS # include <cmalib_crtlx.h> # else# include <dce/cmalib_crtlx.h> # endif#endif # ifndef _CMA_NOWRAPPERS_ # if !_CMA_REENTRANT_CLIB_ # if _CMA_OS_ == _CMA__VMS # include <cmalib_crtlx.h> # else# include <dce/cma_errno.h> # include <dce/cmalib_crtlx.h> # include <dce/cma_stdio.h> # endif# elif (_CMA_UNIX_TYPE == _CMA__SVR4) /* * SVR4 reentrant libraries do not have per-thread errno. */ # include <dce/cma_errno.h> # endif# if _CMA_OS_ == _CMA__UNIX # include <dce/cma_ux.h> # endif# if _CMA_OS_ == _CMA__VMS # include <cma_sigwait.h> # else# include <dce/cma_sigwait.h> # endif# endif # ifdef _HP_LIBC_R # undef wait # include <cma_libc_calls.h> # endif #endif </"dce/cma.h> ----------------------------------------------------------------------- DISCLAIMER: Information contained in this message and/or attachment(s) may contain confidential information of Zetec, Inc. If you have received this transmission in error, please notify the sender by return email. -----------------------------------------------------------------------

2 1

boost python error catching
by cseymour＠interchange.ubc.ca 15 Aug '02

15 Aug '02

Hi, I have some code that worked fine with Python 2.1, but now in Python 2.2.1 it segfaults mysteriuosly. I've narrowed it down to weirdness with the throw/catch of errors. When I do a throw "boost::python::error_already_set();", the "catch(...)" in my module cpp file is supposed to catch it. But it never gets to there. After it's thrown, Python just segfaults and dies. In Python 2.1 it worked perfectly but not in 2.2.1. Any suggestions?

1 0