Changeset 433


Ignore:
Timestamp:
May 10, 2006 7:24:40 PM (19 years ago)
Author:
bennylp
Message:

Merge-in RTEMS port patch by Phil Torre <ptorre@…>, alpha release.

Location:
pjproject/trunk
Files:
8 added
31 edited
2 moved

Legend:

Unmodified
Added
Removed

  • pjproject/trunk/README-configure

    r432 r433  
    1 # 
    2 # This file contains all possible values for the build.mak. Select 
    3 # the appropriate settings, and put it in build.mak. 
    4 # 
    5 # (Just in case "./configure" fails to detect the appropriate values). 
    6 # 
    7 # Build configurations: 
    8 # 
    9 # MACHINE_NAME values:  
    10 #       - i386 (generic x86) 
    11 #       - sparc 
    12 #       - alpha 
    13 # 
    14 # OS_NAME values: 
    15 #       - win32 (generic windows) 
    16 #       - linux 
    17 #       - sunos 
    18 # 
    19 # CC_NAME values: 
    20 #       - gcc 
    21 #       - msvc 
    22 # 
    23 # HOST_NAME values: 
    24 #       - win32 (Windows command line) 
    25 #       - mingw (Windows, mingw) 
    26 #       - unix 
    27 # 
    281 
    29 # 
    30 # PalmOS 6 cross-compile, cygwin 
    31 # 
    32 #export MACHINE_NAME := m68k 
    33 #export OS_NAME := palmos 
    34 #export CC_NAME := gcc 
    35 #export HOST_NAME := mingw 
     2   Configuring the Build System 
     3   Update: 04 May 2006 
    364 
    37 # 
    38 # Win32, mingw 
    39 # 
    40 #export MACHINE_NAME := i386 
    41 #export OS_NAME := win32 
    42 #export CC_NAME := gcc 
    43 #export HOST_NAME := mingw 
    445 
    45 # 
    46 # Linux i386, gcc 
    47 # 
    48 export MACHINE_NAME := i386 
    49 export OS_NAME := linux 
    50 export CC_NAME := gcc 
    51 export HOST_NAME := unix 
     6  1. Overview 
     7   
     8  The "configure" script in pjproject root directory is not an autoconf script, 
     9but it's just a custom script to generate "build.mak" for the build system.  
     10The "build.mak" file declares the following global Makefile variables: 
    5211 
    53 # 
    54 # Linux KERNEL i386, gcc 
    55 # 
    56 #export MACHINE_NAME := i386 
    57 #export OS_NAME := linux-kernel 
    58 #export CC_NAME := gcc 
    59 #export HOST_NAME := unix 
    60 #export PJPROJECT_DIR := /usr/src/pjproject-0.3 
    61 ##export KERNEL_DIR = /usr/src/linux 
    62 #export KERNEL_DIR = /usr/src/uml/linux 
    63 #export KERNEL_ARCH = ARCH=um 
     12  MACHINE_NAME 
     13    The processor and hardware platform of the target. For each MACHINE_NAME, 
     14    there must be matching "m-*.mak" entry in "build/" subdirectory. For  
     15    example, when MACHINE_NAME is declared as "i386", then there must be  
     16    "m-i386.mak" file in "build/" subdirectory. 
     17   
     18  OS_NAME 
     19    Operating system name, determines which "os-*.mak" in "build/" dir to use. 
    6420 
    65 # 
    66 # SunOS, sparc, gcc 
    67 # 
    68 #export MACHINE_NAME := sparc 
    69 #export OS_NAME := sunos 
    70 #export CC_NAME := gcc 
    71 #export HOST_NAME := unix 
     21  HOST_NAME 
     22     Build host name, determines which "host-*.mak" to use. 
    7223 
     24  CC_NAME 
     25     Compiler name, determines which "cc-*.mak" to use. 
     26 
     27  TARGET_NAME 
     28     Determines suffix to be added to output files (for example, 
     29     "libpjsip-i386-linux-gcc.a"). The value normally is equal to 
     30     $(MACHINE_NAME)-$(OS_NAME)-$(CC_NAME), but it can contain any value. 
     31   
     32  CROSS_COMPILE 
     33     Determine the prefix to be applied when invoking build tools (for 
     34     example, "powerpc-rtems-"). The default is empty. 
     35 
     36 
     37  At present, the configure script CAN NOT be used for configuring cross 
     38compilation. For cross compiling, you must create the "build.mak" file 
     39manually. 
     40 
     41 
     42  2. Supported Hosts and Targets 
     43 
     44  The number of supported hosts and targets will (hopefully) increase over time. 
     45See "build/" subdirectory for list of supported machines, OSes, hosts, and 
     46compilers. 
     47 

  • pjproject/trunk/build/cc-gcc.mak

    r65 r433  
    11export CC = $(CROSS_COMPILE)gcc -c 
    2 export AR = $(CROSS_COMPILE)ar r  
     2export AR = $(CROSS_COMPILE)ar rv  
    33export LD = $(CROSS_COMPILE)gcc 
    44export LDOUT = -o  

  • pjproject/trunk/build/host-unix.mak

    r65 r433  
    33export HOST_RMR := rm -rf @@ 
    44export HOST_RMDIR := rm -rf @@ 
    5 export HOST_MKDIR := mkdir @@ 
     5export HOST_MKDIR := mkdir -p @@ 
    66export HOST_EXE :=  
    77export HOST_PSEP := / 

  • pjproject/trunk/build/rules.mak

    r431 r433  
    155155           if test -f $$F; then \ 
    156156             echo "$(OBJDIR)/" | tr -d '\n' >> $(DEP_FILE); \ 
    157              if gcc -M $(DEPFLAGS) $$F | sed '/^#/d' >> $(DEP_FILE); then \ 
     157             if $(CC_NAME) -M $(DEPFLAGS) $$F | sed '/^#/d' >> $(DEP_FILE); then \ 
    158158                true; \ 
    159159             else \ 

  • pjproject/trunk/configure

    r431 r433  
    22 
    33# 
    4 # Detect machine 
     4# Detect machine, unless the choice has been made already. 
    55# 
    6 MACHINE=`uname -p` 
    7 if echo $MACHINE | grep unknown > /dev/null; then 
    8     MACHINE=`uname -m` 
    9 fi; 
     6if [ "$MACHINE" = "" ]; then 
     7        MACHINE=`uname -m` 
     8fi       
    109 
    11 if echo $MACHINE | grep sparc > /dev/null; then 
     10if echo $MACHINE | grep sun4u > /dev/null; then 
    1211    MACHINE_NAME=sparc 
    1312elif echo $MACHINE | grep i.86 > /dev/null; then 
    … …  
    1817    MACHINE_NAME=powerpc 
    1918else 
    20     echo "Unable to detect processor type ('uname -p' == '$MACHINE')" 
     19    echo "Unable to detect processor type ('uname -m' == '$MACHINE')" 
    2120    exit 1 
    2221fi 
    2322 
    2423# 
    25 # Detect OS and host 
     24# Detect OS and host, unless the choice has been made already 
    2625# 
    27 SYSTEM=`uname -s` 
     26if [ "$SYSTEM" = "" ]; then 
     27    SYSTEM=`uname -s` 
     28fi       
     29  
    2830 
    2931if echo $SYSTEM | grep -i sunos > /dev/null; then 
    … …  
    5456    OS_NAME=darwinos 
    5557    HOST_NAME=unix 
     58elif echo $SYSTEM | grep -i rtems > /dev/null; then 
     59    OS_NAME=rtems 
     60    HOST_NAME=unix 
    5661else 
    5762    echo "Unable to detect system type ('uname -s' == '$SYSTEM')" 
    … …  
    6065 
    6166# 
    62 # Detect gcc 
     67# Detect gcc, unless it has been chosen already 
    6368# 
    64 if gcc --version 2>&1 > /dev/null; then 
    65     CC_NAME=gcc 
    66 else 
    67     echo "Unable to find gcc" 
    68     exit 1 
    69 fi 
     69if [ "$CC_NAME" = "" ]; then 
     70        if gcc --version 2>&1 > /dev/null; then 
     71                CC_NAME=gcc 
     72        else 
     73                echo "Unable to find gcc" 
     74                exit 1 
     75        fi 
     76fi       
     77  
    7078 
    7179# 
    72 # TARGET 
     80# Specify TARGET_NAME, if not already choosen. 
    7381# 
    74 TARGET_NAME=$MACHINE_NAME-$OS_NAME-$CC_NAME 
     82if [ "$TARGET_NAME" = "" ]; then 
     83   TARGET_NAME=$MACHINE_NAME-$OS_NAME-$CC_NAME 
     84fi 
    7585 
    7686 
    … …  
    8696echo " CC_NAME      = $CC_NAME" 
    8797echo " TARGET_NAME  = $TARGET_NAME" 
     98echo " CROSS_COMPILE= $CROSS_COMPILE" 
    8899echo " LINUX_POLL   = $LINUX_POLL" 
    89100 
    … …  
    94105echo "export CC_NAME := $CC_NAME" >> build.mak 
    95106echo "export TARGET_NAME := $TARGET_NAME" >> build.mak 
     107echo "export CROSS_COMPILE := $CROSS_COMPILE" >> build.mak 
    96108echo "export LINUX_POLL := $LINUX_POLL" >> build.mak 
    97109 

  • pjproject/trunk/pjlib/include/pj/compat/os_darwinos.h

    r338 r433  
    9595 */ 
    9696typedef int socklen_t; 
     97 
     98/* Set 1 if native sockaddr_in has sin_len member.  
     99 * Default: 0 
     100 */ 
    97101#define PJ_SOCKADDR_HAS_LEN             1 
    98102 
    … …  
    106110#define PJ_IOQUEUE_MAX_HANDLES          1024 
    107111 
     112/** 
     113 * If this macro is set, it tells select I/O Queue that select() needs to 
     114 * be given correct value of nfds (i.e. largest fd + 1). This requires 
     115 * select ioqueue to re-scan the descriptors on each registration and 
     116 * unregistration. 
     117 * If this macro is not set, then ioqueue will always give FD_SETSIZE for 
     118 * nfds argument when calling select(). 
     119 * 
     120 * Default: 0 
     121 */ 
     122#define PJ_SELECT_NEEDS_NFDS            0 
     123 
     124/* If 1, use Read/Write mutex emulation for platforms that don't support it */ 
     125#define PJ_EMULATE_RWMUTEX              0 
     126 
     127/* If 1, pj_thread_create() should enforce the stack size when creating  
     128 * threads. 
     129 * Default: 0 (let OS decide the thread's stack size). 
     130 */ 
     131#define PJ_THREAD_SET_STACK_SIZE        0 
     132 
     133/* If 1, pj_thread_create() should allocate stack from the pool supplied. 
     134 * Default: 0 (let OS allocate memory for thread's stack). 
     135 */ 
     136#define PJ_THREAD_ALLOCATE_STACK        0 
     137 
    108138 
    109139#endif  /* __PJ_COMPAT_OS_DARWINOS_H__ */ 

  • pjproject/trunk/pjlib/include/pj/compat/os_linux.h

    r356 r433  
    5555 
    5656#define PJ_SOCK_HAS_INET_ATON       1 
     57 
     58/* Set 1 if native sockaddr_in has sin_len member.  
     59 * Default: 0 
     60 */ 
    5761#define PJ_SOCKADDR_HAS_LEN         0 
     62 
     63/** 
     64 * If this macro is set, it tells select I/O Queue that select() needs to 
     65 * be given correct value of nfds (i.e. largest fd + 1). This requires 
     66 * select ioqueue to re-scan the descriptors on each registration and 
     67 * unregistration. 
     68 * If this macro is not set, then ioqueue will always give FD_SETSIZE for 
     69 * nfds argument when calling select(). 
     70 * 
     71 * Default: 0 
     72 */ 
     73#define PJ_SELECT_NEEDS_NFDS        0 
    5874 
    5975/* Is errno a good way to retrieve OS errors? 
    … …  
    90106#define PJ_ATOMIC_VALUE_TYPE        long 
    91107 
     108/* If 1, use Read/Write mutex emulation for platforms that don't support it */ 
     109#define PJ_EMULATE_RWMUTEX          0 
     110 
     111/* If 1, pj_thread_create() should enforce the stack size when creating  
     112 * threads. 
     113 * Default: 0 (let OS decide the thread's stack size). 
     114 */ 
     115#define PJ_THREAD_SET_STACK_SIZE        0 
     116 
     117/* If 1, pj_thread_create() should allocate stack from the pool supplied. 
     118 * Default: 0 (let OS allocate memory for thread's stack). 
     119 */ 
     120#define PJ_THREAD_ALLOCATE_STACK        0 
     121 
     122 
     123 
    92124#endif  /* __PJ_COMPAT_OS_LINUX_H__ */ 
    93125 

  • pjproject/trunk/pjlib/include/pj/compat/os_linux_kernel.h

    r338 r433  
    5555 
    5656#define PJ_SOCK_HAS_INET_ATON       0 
     57 
     58/* Set 1 if native sockaddr_in has sin_len member.  
     59 * Default: 0 
     60 */ 
    5761#define PJ_SOCKADDR_HAS_LEN         0 
    5862 
    … …  
    6165 */ 
    6266#define PJ_HAS_SO_ERROR             1 
     67 
     68/** 
     69 * If this macro is set, it tells select I/O Queue that select() needs to 
     70 * be given correct value of nfds (i.e. largest fd + 1). This requires 
     71 * select ioqueue to re-scan the descriptors on each registration and 
     72 * unregistration. 
     73 * If this macro is not set, then ioqueue will always give FD_SETSIZE for 
     74 * nfds argument when calling select(). 
     75 * 
     76 * Default: 0 
     77 */ 
     78#define PJ_SELECT_NEEDS_NFDS        0 
    6379 
    6480/* This value specifies the value set in errno by the OS when a non-blocking 
    … …  
    105121#define PJ_THREAD_DESC_SIZE         128 
    106122 
     123/* If 1, use Read/Write mutex emulation for platforms that don't support it */ 
     124#define PJ_EMULATE_RWMUTEX          0 
     125 
     126/* If 1, pj_thread_create() should enforce the stack size when creating  
     127 * threads. 
     128 * Default: 0 (let OS decide the thread's stack size). 
     129 */ 
     130#define PJ_THREAD_SET_STACK_SIZE        0 
     131 
     132/* If 1, pj_thread_create() should allocate stack from the pool supplied. 
     133 * Default: 0 (let OS allocate memory for thread's stack). 
     134 */ 
     135#define PJ_THREAD_ALLOCATE_STACK        0 
     136 
     137 
     138 
    107139#endif  /* __PJ_COMPAT_OS_LINUX_KERNEL_H__ */ 
    108140 

  • pjproject/trunk/pjlib/include/pj/compat/os_palmos.h

    r338 r433  
    5353 
    5454#define PJ_SOCK_HAS_INET_ATON       0 
     55 
     56/* Set 1 if native sockaddr_in has sin_len member.  
     57 * Default: 0 
     58 */ 
    5559#define PJ_SOCKADDR_HAS_LEN         0 
     60 
     61/** 
     62 * If this macro is set, it tells select I/O Queue that select() needs to 
     63 * be given correct value of nfds (i.e. largest fd + 1). This requires 
     64 * select ioqueue to re-scan the descriptors on each registration and 
     65 * unregistration. 
     66 * If this macro is not set, then ioqueue will always give FD_SETSIZE for 
     67 * nfds argument when calling select(). 
     68 * 
     69 * Default: 0 
     70 */ 
     71#define PJ_SELECT_NEEDS_NFDS        0 
    5672 
    5773/* Is errno a good way to retrieve OS errors? 
    … …  
    84100#define PJ_NATIVE_STRING_IS_UNICODE     0 
    85101 
     102/* If 1, use Read/Write mutex emulation for platforms that don't support it */ 
     103#define PJ_EMULATE_RWMUTEX              1 
     104 
     105/* If 1, pj_thread_create() should enforce the stack size when creating  
     106 * threads. 
     107 * Default: 0 (let OS decide the thread's stack size). 
     108 */ 
     109#define PJ_THREAD_SET_STACK_SIZE        0 
     110 
     111/* If 1, pj_thread_create() should allocate stack from the pool supplied. 
     112 * Default: 0 (let OS allocate memory for thread's stack). 
     113 */ 
     114#define PJ_THREAD_ALLOCATE_STACK        0 
     115 
     116 
    86117#endif  /* __PJ_COMPAT_OS_PALMOS_H__ */ 
     118 

  • pjproject/trunk/pjlib/include/pj/compat/os_sunos.h

    r338 r433  
    5555 
    5656#define PJ_SOCK_HAS_INET_ATON       0 
     57 
     58/* Set 1 if native sockaddr_in has sin_len member.  
     59 * Default: 0 
     60 */ 
    5761#define PJ_SOCKADDR_HAS_LEN         0 
    5862 
    … …  
    7680#define PJ_BLOCKING_CONNECT_ERROR_VAL   EINPROGRESS 
    7781 
     82/** 
     83 * If this macro is set, it tells select I/O Queue that select() needs to 
     84 * be given correct value of nfds (i.e. largest fd + 1). This requires 
     85 * select ioqueue to re-scan the descriptors on each registration and 
     86 * unregistration. 
     87 * If this macro is not set, then ioqueue will always give FD_SETSIZE for 
     88 * nfds argument when calling select(). 
     89 * 
     90 * Default: 0 
     91 */ 
     92#define PJ_SELECT_NEEDS_NFDS            0 
     93 
    7894/* Default threading is enabled, unless it's overridden. */ 
    7995#ifndef PJ_HAS_THREADS 
    … …  
    93109#define BSD_COMP 
    94110 
     111/* If 1, use Read/Write mutex emulation for platforms that don't support it */ 
     112#define PJ_EMULATE_RWMUTEX              0 
     113 
     114/* If 1, pj_thread_create() should enforce the stack size when creating  
     115 * threads. 
     116 * Default: 0 (let OS decide the thread's stack size). 
     117 */ 
     118#define PJ_THREAD_SET_STACK_SIZE        0 
     119 
     120/* If 1, pj_thread_create() should allocate stack from the pool supplied. 
     121 * Default: 0 (let OS allocate memory for thread's stack). 
     122 */ 
     123#define PJ_THREAD_ALLOCATE_STACK        0 
     124 
     125 
     126 
    95127#endif  /* __PJ_COMPAT_OS_SUNOS_H__ */ 
    96128 

  • pjproject/trunk/pjlib/include/pj/compat/os_win32.h

    r338 r433  
    6161 
    6262#define PJ_SOCK_HAS_INET_ATON       0 
     63 
     64/* Set 1 if native sockaddr_in has sin_len member.  
     65 * Default: 0 
     66 */ 
    6367#define PJ_SOCKADDR_HAS_LEN         0 
    6468 
    … …  
    8286#define PJ_BLOCKING_CONNECT_ERROR_VAL   WSAEWOULDBLOCK 
    8387 
     88/** 
     89 * If this macro is set, it tells select I/O Queue that select() needs to 
     90 * be given correct value of nfds (i.e. largest fd + 1). This requires 
     91 * select ioqueue to re-scan the descriptors on each registration and 
     92 * unregistration. 
     93 * If this macro is not set, then ioqueue will always give FD_SETSIZE for 
     94 * nfds argument when calling select(). 
     95 * 
     96 * Default: 0 
     97 */ 
     98#define PJ_SELECT_NEEDS_NFDS            0 
     99 
    84100/* Default threading is enabled, unless it's overridden. */ 
    85101#ifndef PJ_HAS_THREADS 
    … …  
    96112#define PJ_ATOMIC_VALUE_TYPE            long 
    97113 
     114/* If 1, use Read/Write mutex emulation for platforms that don't support it */ 
     115#define PJ_EMULATE_RWMUTEX              1 
     116 
     117/* If 1, pj_thread_create() should enforce the stack size when creating  
     118 * threads. 
     119 * Default: 0 (let OS decide the thread's stack size). 
     120 */ 
     121#define PJ_THREAD_SET_STACK_SIZE        0 
     122 
     123/* If 1, pj_thread_create() should allocate stack from the pool supplied. 
     124 * Default: 0 (let OS allocate memory for thread's stack). 
     125 */ 
     126#define PJ_THREAD_ALLOCATE_STACK        0 
     127 
     128 
    98129#endif  /* __PJ_COMPAT_OS_WIN32_H__ */ 
     130 

  • pjproject/trunk/pjlib/include/pj/compat/os_win32_wince.h

    r338 r433  
    5959 
    6060#define PJ_SOCK_HAS_INET_ATON       0 
     61 
     62/* Set 1 if native sockaddr_in has sin_len member.  
     63 * Default: 0 
     64 */ 
    6165#define PJ_SOCKADDR_HAS_LEN         0 
    6266 
    … …  
    7983 */ 
    8084#define PJ_BLOCKING_CONNECT_ERROR_VAL   WSAEWOULDBLOCK 
     85 
     86/** 
     87 * If this macro is set, it tells select I/O Queue that select() needs to 
     88 * be given correct value of nfds (i.e. largest fd + 1). This requires 
     89 * select ioqueue to re-scan the descriptors on each registration and 
     90 * unregistration. 
     91 * If this macro is not set, then ioqueue will always give FD_SETSIZE for 
     92 * nfds argument when calling select(). 
     93 * 
     94 * Default: 0 
     95 */ 
     96#define PJ_SELECT_NEEDS_NFDS        0 
    8197 
    8298/* Default threading is enabled, unless it's overridden. */ 
    … …  
    103119#define PJ_NATIVE_STRING_IS_UNICODE 1 
    104120 
     121/* If 1, use Read/Write mutex emulation for platforms that don't support it */ 
     122#define PJ_EMULATE_RWMUTEX          1 
     123 
     124/* If 1, pj_thread_create() should enforce the stack size when creating  
     125 * threads. 
     126 * Default: 0 (let OS decide the thread's stack size). 
     127 */ 
     128#define PJ_THREAD_SET_STACK_SIZE        0 
     129 
     130/* If 1, pj_thread_create() should allocate stack from the pool supplied. 
     131 * Default: 0 (let OS allocate memory for thread's stack). 
     132 */ 
     133#define PJ_THREAD_ALLOCATE_STACK        0 
     134 
     135 
    105136#endif  /* __PJ_COMPAT_OS_WIN32_WINCE_H__ */ 
    106137 

  • pjproject/trunk/pjlib/include/pj/config.h

    r364 r433  
    5454#elif defined(PJ_DARWINOS) && PJ_DARWINOS!=0 
    5555#  include <pj/compat/os_darwinos.h> 
     56#elif defined(PJ_RTEMS) && PJ_RTEMS!=0 
     57#  include <pj/compat/os_rtems.h> 
    5658#else 
    5759#  error "Please specify target os." 
    … …  
    224226 
    225227/** 
     228 * Specify this as \a stack_size argument in #pj_thread_create() to specify 
     229 * that thread should use default stack size for the current platform. 
     230 * 
     231 * Default: 8192 
     232 */ 
     233#ifndef PJ_THREAD_DEFAULT_STACK_SIZE  
     234#  define PJ_THREAD_DEFAULT_STACK_SIZE    8192 
     235#endif 
     236 
     237 
     238/** 
    226239 * Do we have alternate pool implementation? 
    227240 * 
    … …  
    557570#endif 
    558571 
    559  
     572#if !defined(PJ_EMULATE_RWMUTEX) 
     573#  error "PJ_EMULATE_RWMUTEX should be defined in compat/os_xx.h" 
     574#endif 
     575 
     576#if !defined(PJ_THREAD_SET_STACK_SIZE) 
     577#  error "PJ_THREAD_SET_STACK_SIZE should be defined in compat/os_xx.h" 
     578#endif 
     579 
     580#if !defined(PJ_THREAD_ALLOCATE_STACK) 
     581#  error "PJ_THREAD_ALLOCATE_STACK should be defined in compat/os_xx.h" 
     582#endif 
    560583 
    561584PJ_BEGIN_DECL 

  • pjproject/trunk/pjlib/include/pj/os.h

    r228 r433  
    5858} pj_thread_create_flags; 
    5959 
    60  
    61 /** 
    62  * Specify this as \a stack_size argument in #pj_thread_create() to specify 
    63  * that thread should use default stack size for the current platform. 
    64  */ 
    65 #define PJ_THREAD_DEFAULT_STACK_SIZE    0 
    6660 
    6761/** 
    … …  
    162156 
    163157/** 
    164  * Join thread. 
    165  * This function will block the caller thread until the specified thread exits. 
     158 * Join thread, and block the caller thread until the specified thread exits. 
     159 * If the specified thread has already been dead, or it does not exist, 
     160 * the function will return immediately with successfull status. 
    166161 * 
    167162 * @param thread    The thread handle. 
    168163 * 
    169  * @return zero on success. 
     164 * @return PJ_SUCCESS on success. 
    170165 */ 
    171166PJ_DECL(pj_status_t) pj_thread_join(pj_thread_t *thread); 

  • pjproject/trunk/pjlib/src/pj/hash.c

    r127 r433  
    5050 
    5151 
    52 PJ_DEF(pj_uint32_t) pj_hash_calc(pj_uint32_t hash, const void *key, unsigned keylen) 
     52PJ_DEF(pj_uint32_t) pj_hash_calc(pj_uint32_t hash, const void *key,  
     53                                 unsigned keylen) 
    5354{ 
    5455    PJ_CHECK_STACK(); 
    … …  
    5758        const unsigned char *p = key; 
    5859        for ( ; *p; ++p ) { 
    59             hash = hash * PJ_HASH_MULTIPLIER + *p; 
     60            hash = (hash * PJ_HASH_MULTIPLIER) + *p; 
    6061        } 
    6162    } else { 
    … …  
    6364                            *end = p + keylen; 
    6465        for ( ; p!=end; ++p) { 
    65             hash = hash * PJ_HASH_MULTIPLIER + *p; 
     66            hash = (hash * PJ_HASH_MULTIPLIER) + *p; 
    6667        } 
    6768    } 

  • pjproject/trunk/pjlib/src/pj/ioqueue_common_abs.c

    r365 r433  
    238238 
    239239            gp_rc = getpeername(h->fd, (struct sockaddr*)&addr, &addrlen); 
    240             bytes_transfered = gp_rc; 
     240            bytes_transfered = (gp_rc < 0) ? gp_rc : -gp_rc; 
    241241        } 
    242242#endif 

  • pjproject/trunk/pjlib/src/pj/ioqueue_select.c

    r365 r433  
    9494#define VALIDATE_FD_SET     0 
    9595 
     96#if 0 
     97#  define TRACE__(args) PJ_LOG(3,args) 
     98#else 
     99#  define TRACE__(args) 
     100#endif 
     101 
    96102/* 
    97103 * This describes each key. 
    … …  
    109115    DECLARE_COMMON_IOQUEUE 
    110116 
    111     unsigned            max, count; 
    112     pj_ioqueue_key_t    active_list; 
     117    unsigned            max, count;     /* Max and current key count        */ 
     118    int                 nfds;           /* The largest fd value (for select)*/ 
     119    pj_ioqueue_key_t    active_list;    /* List of active keys.             */ 
    113120    pj_fd_set_t         rfdset; 
    114121    pj_fd_set_t         wfdset; 
    … …  
    136143    return "select"; 
    137144} 
     145 
     146/*  
     147 * Scan the socket descriptor sets for the largest descriptor. 
     148 * This value is needed by select(). 
     149 */ 
     150#if defined(PJ_SELECT_NEEDS_NFDS) && PJ_SELECT_NEEDS_NFDS!=0 
     151static void rescan_fdset(pj_ioqueue_t *ioqueue) 
     152{ 
     153    pj_ioqueue_key_t *key = ioqueue->active_list.next; 
     154    int max = 0; 
     155 
     156    while (key != &ioqueue->active_list) { 
     157        if (key->fd > max) 
     158            max = key->fd; 
     159        key = key->next; 
     160    } 
     161 
     162    ioqueue->nfds = max; 
     163} 
     164#else 
     165static void rescan_fdset(pj_ioqueue_t *ioqueue) 
     166{ 
     167    ioqueue->nfds = FD_SETSIZE-1; 
     168} 
     169#endif 
     170 
    138171 
    139172/* 
    … …  
    172205#endif 
    173206    pj_list_init(&ioqueue->active_list); 
     207 
     208    rescan_fdset(ioqueue); 
    174209 
    175210#if PJ_IOQUEUE_HAS_SAFE_UNREG 
    … …  
    333368    ++ioqueue->count; 
    334369 
     370    /* Rescan fdset to get max descriptor */ 
     371    rescan_fdset(ioqueue); 
     372 
    335373on_return: 
    336374    /* On error, socket may be left in non-blocking mode. */ 
    … …  
    369407        pj_list_erase(key); 
    370408        pj_list_push_back(&key->ioqueue->closing_list, key); 
     409        /* Rescan fdset to get max descriptor */ 
     410        rescan_fdset(key->ioqueue); 
    371411        pj_lock_release(key->ioqueue->lock); 
    372412    } 
    … …  
    612652#endif 
    613653        pj_lock_release(ioqueue->lock); 
     654        TRACE__((THIS_FILE, "     poll: no fd is set")); 
    614655        if (timeout) 
    615656            pj_thread_sleep(PJ_TIME_VAL_MSEC(*timeout)); 
    … …  
    633674    pj_lock_release(ioqueue->lock); 
    634675 
    635     count = pj_sock_select(FD_SETSIZE, &rfdset, &wfdset, &xfdset, timeout); 
     676    count = pj_sock_select(ioqueue->nfds+1, &rfdset, &wfdset, &xfdset,  
     677                           timeout); 
    636678     
    637679    if (count <= 0) 

  • pjproject/trunk/pjlib/src/pj/os_core_unix.c

    r338 r433  
    1717 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  
    1818 */ 
     19/* 
     20 * Contributors: 
     21 * - Thanks for Zetron, Inc. (Phil Torre, ptorre@zetron.com) for donating 
     22 *   the RTEMS port. 
     23 */ 
    1924#define _GNU_SOURCE 
    2025#include <pj/os.h> 
    … …  
    154159#endif    
    155160 
    156     PJ_LOG(4,(THIS_FILE, "pjlib %s for Unix initialized", 
     161    PJ_LOG(4,(THIS_FILE, "pjlib %s for POSIX initialized", 
    157162              PJ_VERSION)); 
    158163 
    … …  
    197202        //*thread_ptr = (pj_thread_t*)pj_thread_local_get (thread_tls_id); 
    198203        //return PJ_SUCCESS; 
     204        PJ_LOG(4,(THIS_FILE, "Info: possibly re-registering existing " 
     205                             "thread")); 
    199206    } 
    200207 
    … …  
    282289    /* Done. */ 
    283290    PJ_LOG(6,(rec->obj_name, "Thread quitting")); 
     291 
    284292    return result; 
    285293} 
    … …  
    299307#if PJ_HAS_THREADS 
    300308    pj_thread_t *rec; 
     309    pthread_attr_t thread_attr; 
     310    void *stack_addr; 
    301311    int rc; 
     312 
     313    PJ_UNUSED_ARG(stack_addr); 
    302314 
    303315    PJ_CHECK_STACK(); 
    … …  
    306318    /* Create thread record and assign name for the thread */ 
    307319    rec = (struct pj_thread_t*) pj_pool_zalloc(pool, sizeof(pj_thread_t)); 
    308     if (!rec) 
    309         return PJ_ENOMEM; 
     320    PJ_ASSERT_RETURN(rec, PJ_ENOMEM); 
    310321     
    311322    /* Set name. */ 
    … …  
    320331    } 
    321332 
     333    /* Set default stack size */ 
     334    if (stack_size == 0) 
     335        stack_size = PJ_THREAD_DEFAULT_STACK_SIZE; 
     336 
    322337#if defined(PJ_OS_HAS_CHECK_STACK) && PJ_OS_HAS_CHECK_STACK!=0 
    323     rec->stk_size = stack_size ? stack_size : 0xFFFFFFFFUL; 
     338    rec->stk_size = stack_size; 
    324339    rec->stk_max_usage = 0; 
    325340#endif 
    … …  
    328343    if (flags & PJ_THREAD_SUSPENDED) { 
    329344        rc = pj_mutex_create_simple(pool, NULL, &rec->suspended_mutex); 
    330         if (rc != PJ_SUCCESS) 
     345        if (rc != PJ_SUCCESS) { 
    331346            return rc; 
     347        } 
    332348 
    333349        pj_mutex_lock(rec->suspended_mutex); 
    … …  
    336352    } 
    337353     
    338     PJ_LOG(6, (rec->obj_name, "Thread created")); 
     354 
     355    /* Init thread attributes */ 
     356    pthread_attr_init(&thread_attr); 
     357 
     358#if defined(PJ_THREAD_SET_STACK_SIZE) && PJ_THREAD_SET_STACK_SIZE!=0 
     359    /* Set thread's stack size */ 
     360    rc = pthread_attr_setstacksize(&thread_attr, stack_size); 
     361    if (rc != 0) 
     362        return PJ_RETURN_OS_ERROR(rc); 
     363#endif  /* PJ_THREAD_SET_STACK_SIZE */ 
     364 
     365 
     366#if defined(PJ_THREAD_ALLOCATE_STACK) && PJ_THREAD_ALLOCATE_STACK!=0 
     367    /* Allocate memory for the stack */ 
     368    stack_addr = pj_pool_alloc(pool, stack_size); 
     369    PJ_ASSERT_RETURN(stack_addr, PJ_ENOMEM); 
     370 
     371    rc = pthread_attr_setstackaddr(&thread_attr, stack_addr); 
     372    if (rc != 0) 
     373        return PJ_RETURN_OS_ERROR(rc); 
     374#endif  /* PJ_THREAD_ALLOCATE_STACK */ 
     375 
    339376 
    340377    /* Create the thread. */ 
    341378    rec->proc = proc; 
    342379    rec->arg = arg; 
    343     rc = pthread_create( &rec->thread, NULL, thread_main, rec); 
    344     if (rc != 0) 
     380    rc = pthread_create( &rec->thread, &thread_attr, &thread_main, rec); 
     381    if (rc != 0) { 
    345382        return PJ_RETURN_OS_ERROR(rc); 
     383    } 
    346384 
    347385    *ptr_thread = rec; 
     386 
     387    PJ_LOG(6, (rec->obj_name, "Thread created")); 
    348388    return PJ_SUCCESS; 
    349389#else 
    … …  
    424464    if (result == 0) 
    425465        return PJ_SUCCESS; 
    426     else 
    427         return PJ_RETURN_OS_ERROR(result); 
     466    else { 
     467        /* Calling pthread_join() on a thread that no longer exists and  
     468         * getting back ESRCH isn't an error (in this context).  
     469         * Thanks Phil Torre <ptorre@zetron.com>. 
     470         */ 
     471        return result==ESRCH ? PJ_SUCCESS : PJ_RETURN_OS_ERROR(result); 
     472    } 
    428473#else 
    429474    PJ_CHECK_STACK(); 
    … …  
    438483PJ_DEF(pj_status_t) pj_thread_destroy(pj_thread_t *p) 
    439484{ 
    440     /* This function is used to destroy thread handle in other platforms. 
    441      * I suppose there's nothing to do here.. 
    442      */ 
    443     PJ_CHECK_STACK(); 
     485    PJ_CHECK_STACK(); 
     486 
     487    /* Destroy mutex used to suspend thread */ 
     488    if (p->suspended_mutex) { 
     489        pj_mutex_destroy(p->suspended_mutex); 
     490        p->suspended_mutex = NULL; 
     491    } 
     492 
    444493    return PJ_SUCCESS; 
    445494} 
    … …  
    450499PJ_DEF(pj_status_t) pj_thread_sleep(unsigned msec) 
    451500{ 
    452     PJ_CHECK_STACK(); 
    453     return usleep(msec * 1000); 
     501/* TODO: should change this to something like PJ_OS_HAS_NANOSLEEP */ 
     502#if defined(PJ_RTEMS) && PJ_RTEMS!=0 
     503    enum { NANOSEC_PER_MSEC = 1000000 }; 
     504    struct timespec req; 
     505 
     506    PJ_CHECK_STACK(); 
     507    req.tv_sec = msec / 1000; 
     508    req.tv_nsec = (msec % 1000) * NANOSEC_PER_MSEC; 
     509 
     510    if (nanosleep(&req, NULL) == 0) 
     511        return PJ_SUCCESS; 
     512 
     513    return PJ_RETURN_OS_ERROR(pj_get_native_os_error()); 
     514#else 
     515    PJ_CHECK_STACK(); 
     516    if (usleep(msec * 1000) == 0) 
     517        return PJ_SUCCESS; 
     518 
     519    return PJ_RETURN_OS_ERROR(pj_get_native_os_error()); 
     520#endif  /* PJ_RTEMS */ 
    454521} 
    455522 
    … …  
    514581    pj_status_t rc; 
    515582    pj_atomic_t *atomic_var = pj_pool_calloc(pool, 1, sizeof(pj_atomic_t)); 
    516     if (!atomic_var) 
    517         return PJ_ENOMEM; 
     583    PJ_ASSERT_RETURN(atomic_var, PJ_ENOMEM); 
    518584     
    519585#if PJ_HAS_THREADS 
    … …  
    766832    PJ_CHECK_STACK(); 
    767833 
    768     pthread_mutexattr_init(&attr); 
     834    rc = pthread_mutexattr_init(&attr); 
     835    if (rc != 0) 
     836        return PJ_RETURN_OS_ERROR(rc); 
    769837 
    770838    if (type == PJ_MUTEX_SIMPLE) { 
    … …  
    772840        extern int pthread_mutexattr_settype(pthread_mutexattr_t*,int); 
    773841        rc = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_FAST_NP); 
     842#elif defined(PJ_RTEMS) && PJ_RTEMS!=0 
     843        /* Nothing to do, default is simple */ 
    774844#else 
    775845        rc = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL); 
    … …  
    779849        extern int pthread_mutexattr_settype(pthread_mutexattr_t*,int); 
    780850        rc = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP); 
     851#elif defined(PJ_RTEMS) && PJ_RTEMS!=0 
     852        // Phil Torre <ptorre@zetron.com>: 
     853        // The RTEMS implementation of POSIX mutexes doesn't include  
     854        // pthread_mutexattr_settype(), so what follows is a hack 
     855        // until I get RTEMS patched to support the set/get functions. 
     856        PJ_TODO(FIX_RTEMS_RECURSIVE_MUTEX_TYPE) 
     857        attr.recursive = 1; 
    781858#else 
    782859        rc = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); 
    … …  
    832909 
    833910    mutex = pj_pool_alloc(pool, sizeof(*mutex)); 
    834     if (!mutex) return PJ_ENOMEM; 
     911    PJ_ASSERT_RETURN(mutex, PJ_ENOMEM); 
    835912 
    836913    if ((rc=init_mutex(mutex, name, type)) != PJ_SUCCESS) 
    … …  
    10031080 
    10041081/////////////////////////////////////////////////////////////////////////////// 
     1082/* 
     1083 * Include Read/Write mutex emulation for POSIX platforms that lack it (e.g. 
     1084 * RTEMS). Otherwise use POSIX rwlock. 
     1085 */ 
     1086#if defined(PJ_EMULATE_RWMUTEX) && PJ_EMULATE_RWMUTEX!=0 
     1087#  include "os_rwmutex.c" 
     1088#else 
    10051089struct pj_rwmutex_t 
    10061090{ 
    … …  
    10951179    return PJ_SUCCESS; 
    10961180} 
     1181 
     1182#endif  /* PJ_EMULATE_RWMUTEX */ 
     1183 
    10971184 
    10981185/////////////////////////////////////////////////////////////////////////////// 
    … …  
    11141201    PJ_ASSERT_RETURN(pool != NULL && ptr_sem != NULL, PJ_EINVAL); 
    11151202 
    1116     sem = pj_pool_alloc(pool, sizeof(*sem));     
    1117     if (!sem) return PJ_ENOMEM; 
     1203    sem = pj_pool_alloc(pool, sizeof(*sem)); 
     1204    PJ_ASSERT_RETURN(sem, PJ_ENOMEM); 
    11181205 
    11191206    if (sem_init( &sem->sem, 0, initial) != 0)  

  • pjproject/trunk/pjlib/src/pj/os_time_unix.c

    r338 r433  
    1818 */ 
    1919#include <pj/os.h> 
     20#include <pj/errno.h> 
    2021#include <pj/compat/time.h> 
    2122 
    … …  
    2425#endif 
    2526 
     27#include <errno.h> 
     28 
    2629/////////////////////////////////////////////////////////////////////////////// 
    2730 
    2831PJ_DEF(pj_status_t) pj_gettimeofday(pj_time_val *p_tv) 
    2932{ 
    30     struct timeval tv; 
     33    struct timeval the_time; 
     34    int rc; 
    3135 
    3236    PJ_CHECK_STACK(); 
    3337 
    34     gettimeofday(&tv, NULL); 
    35     p_tv->sec = tv.tv_sec; 
    36     p_tv->msec = tv.tv_usec / 1000; 
     38    rc = gettimeofday(&the_time, NULL); 
     39    if (rc != 0) 
     40        return PJ_RETURN_OS_ERROR(pj_get_native_os_error()); 
     41 
     42    p_tv->sec = the_time.tv_sec; 
     43    p_tv->msec = the_time.tv_usec / 1000; 
    3744    return PJ_SUCCESS; 
    3845} 

  • pjproject/trunk/pjlib/src/pj/pool.c

    r364 r433  
    174174    PJ_CHECK_STACK(); 
    175175 
     176    /* If callback is NULL, set calback from the policy */ 
     177    if (callback == NULL) 
     178        callback = f->policy.callback; 
     179 
     180    /* Allocate initial block */ 
    176181    buffer = (*f->policy.block_alloc)(f, initial_size); 
    177182    if (!buffer) 

  • pjproject/trunk/pjlib/src/pj/sock_bsd.c

    r348 r433  
    2727/* 
    2828 * Address families conversion. 
    29  * The values here are indexed based on pj_addr_family-0xFF00. 
     29 * The values here are indexed based on pj_addr_family. 
    3030 */ 
    3131const pj_uint16_t PJ_AF_UNIX    = AF_UNIX; 
    … …  
    4545/* 
    4646 * Socket types conversion. 
    47  * The values here are indexed based on pj_sock_type-0xFF00 
     47 * The values here are indexed based on pj_sock_type 
    4848 */ 
    4949const pj_uint16_t PJ_SOCK_STREAM        = SOCK_STREAM; 
    … …  
    347347    PJ_CHECK_STACK(); 
    348348 
    349     PJ_ASSERT_RETURN(addr && len > 0, PJ_EINVAL); 
     349    PJ_ASSERT_RETURN(addr && len >= sizeof(struct sockaddr_in), PJ_EINVAL); 
    350350 
    351351    if (bind(sock, (struct sockaddr*)addr, len) != 0) 

  • pjproject/trunk/pjlib/src/pjlib-test/ioq_tcp.c

    r65 r433  
    344344            } 
    345345 
     346            if (status > pending_op) { 
     347                PJ_LOG(3,(THIS_FILE, 
     348                          "...error: pj_ioqueue_poll() returned %d " 
     349                          "(only expecting %d)", 
     350                          status, pending_op)); 
     351                return -52; 
     352            } 
    346353            pending_op -= status; 
    347354 
    … …  
    479486            } 
    480487 
     488            if (status > pending_op) { 
     489                PJ_LOG(3,(THIS_FILE, 
     490                          "...error: pj_ioqueue_poll() returned %d " 
     491                          "(only expecting %d)", 
     492                          status, pending_op)); 
     493                return -552; 
     494            } 
     495 
    481496            pending_op -= status; 
    482497            if (pending_op == 0) { 

  • pjproject/trunk/pjlib/src/pjlib-test/ioq_udp.c

    r365 r433  
    4242#define PORT                51233 
    4343#define LOOP                100 
     44///#define LOOP             2 
    4445#define BUF_MIN_SIZE        32 
    4546#define BUF_MAX_SIZE        2048 
    … …  
    5051#undef TRACE_ 
    5152#define TRACE_(msg)         PJ_LOG(3,(THIS_FILE,"....." msg)) 
     53 
     54#if 0 
     55#  define TRACE__(args)     PJ_LOG(3,args) 
     56#else 
     57#  define TRACE__(args) 
     58#endif 
     59 
    5260 
    5361static pj_ssize_t            callback_read_size, 
    … …  
    7078    callback_read_op = op_key; 
    7179    callback_read_size = bytes_read; 
     80    TRACE__((THIS_FILE, "     callback_read_key = %p, bytes=%d",  
     81             key, bytes_read)); 
    7282} 
    7383 
    … …  
    255265            status=-45; goto on_error; 
    256266        } else if (rc < 0) { 
    257             app_perror("...ERROR in ioqueue_poll()", rc); 
     267            app_perror("...ERROR in ioqueue_poll()", -rc); 
    258268            status=-50; goto on_error; 
    259269        } 
    … …  
    493503    pj_ioqueue_key_t **key; 
    494504    pj_status_t rc; 
    495     int count, i; 
     505    int count, i; /* must be signed */ 
    496506 
    497507    PJ_LOG(3,(THIS_FILE,"...testing with so many handles")); 
    … …  
    534544    /* Now deregister and close all handles. */  
    535545 
    536     for (i=0; i<count; ++i) { 
     546    /* NOTE for RTEMS: 
     547     *  It seems that the order of close(sock) is pretty important here. 
     548     *  If we close the sockets with the same order as when they were created, 
     549     *  RTEMS doesn't seem to reuse the sockets, thus next socket created 
     550     *  will have descriptor higher than the last socket created. 
     551     *  If we close the sockets in the reverse order, then the descriptor will 
     552     *  get reused. 
     553     *  This used to cause problem with select ioqueue, since the ioqueue 
     554     *  always gives FD_SETSIZE for the first select() argument. This ioqueue 
     555     *  behavior can be changed with setting PJ_SELECT_NEEDS_NFDS macro. 
     556     */ 
     557    for (i=count-1; i>=0; --i) { 
     558    ///for (i=0; i<count; ++i) { 
    537559        rc = pj_ioqueue_unregister(key[i]); 
    538560        if (rc != PJ_SUCCESS) { 
    … …  
    571593    pj_ioqueue_key_t *skey, *ckey, *key; 
    572594    pj_timestamp t1, t2, t_elapsed; 
    573     int rc=0, i; 
     595    int rc=0, i;    /* i must be signed */ 
    574596    pj_str_t temp; 
    575     char errbuf[128]; 
     597    char errbuf[PJ_ERR_MSG_SIZE]; 
     598 
     599    TRACE__((THIS_FILE, "   bench test %d", inactive_sock_count)); 
    576600 
    577601    // Create pool. 
    … …  
    692716                               &addr, sizeof(addr)); 
    693717        if (rc != PJ_SUCCESS && rc != PJ_EPENDING) { 
    694             app_perror("...error: pj_ioqueue_write()", bytes); 
     718            app_perror("...error: pj_ioqueue_write()", rc); 
    695719            break; 
     720        } 
     721        if (rc == PJ_SUCCESS) { 
     722            if (bytes < 0) { 
     723                app_perror("...error: pj_ioqueue_sendto()", -bytes); 
     724                break; 
     725            } 
    696726        } 
    697727 
    … …  
    702732        callback_read_key = NULL; 
    703733        callback_read_size = 0; 
     734        TRACE__((THIS_FILE, "     waiting for key = %p", skey)); 
    704735        do { 
    705             rc = pj_ioqueue_poll(ioque, NULL); 
     736            pj_time_val timeout = { 1, 0 }; 
     737            rc = pj_ioqueue_poll(ioque, &timeout); 
     738            TRACE__((THIS_FILE, "     poll rc=%d", rc)); 
    706739        } while (rc >= 0 && callback_read_key != skey); 
    707740 
    … …  
    750783 
    751784    // Cleaning up. 
    752     for (i=0; i<inactive_sock_count; ++i) 
     785    for (i=inactive_sock_count-1; i>=0; --i) { 
    753786        pj_sock_close(inactive_sock[i]); 
     787    } 
     788 
    754789    pj_sock_close(ssock); 
    755790    pj_sock_close(csock); 
     791 
    756792 
    757793    pj_ioqueue_destroy(ioque); 

  • pjproject/trunk/pjlib/src/pjlib-test/pool_perf.c

    r65 r433  
    3333#define COUNT       1024 
    3434static unsigned     sizes[COUNT]; 
     35static char        *p[COUNT]; 
    3536#define MIN_SIZE    4 
    3637#define MAX_SIZE    512 
    3738static unsigned total_size; 
     39 
    3840 
    3941static int pool_test_pool() 
    … …  
    4648    for (i=0; i<COUNT; ++i) { 
    4749        char *p; 
    48         if ( (p=(char*)pj_pool_alloc(pool, sizes[i])) == NULL) 
     50        if ( (p=(char*)pj_pool_alloc(pool, sizes[i])) == NULL) { 
     51            PJ_LOG(3,(THIS_FILE,"   error: pool failed to allocate %d bytes", 
     52                      sizes[i])); 
     53            pj_pool_release(pool); 
    4954            return -1; 
     55        } 
    5056        *p = '\0'; 
    5157    } 
    … …  
    5763static int pool_test_malloc_free() 
    5864{ 
    59     char *p[COUNT]; 
    60     int i; 
     65    int i; /* must be signed */ 
    6166 
    6267    for (i=0; i<COUNT; ++i) { 
    6368        p[i] = (char*)malloc(sizes[i]); 
    6469        if (!p[i]) { 
    65             // Don't care for memory leak in this test 
     70            PJ_LOG(3,(THIS_FILE,"   error: malloc failed to allocate %d bytes", 
     71                      sizes[i])); 
     72            --i; 
     73            while (i >= 0) 
     74                free(p[i]), --i; 
    6675            return -1; 
    6776        } 
    … …  
    8392    pj_uint32_t best, worst; 
    8493 
    85     // Initialize sizes. 
     94    /* Initialize size of chunks to allocate in for the test. */ 
    8695    for (i=0; i<COUNT; ++i) { 
    87         sizes[i] = MIN_SIZE + pj_rand() % MAX_SIZE; 
     96        sizes[i] = MIN_SIZE + (pj_rand() % MAX_SIZE); 
    8897        total_size += sizes[i]; 
    8998    } 
    9099 
     100    /* Add some more for pool admin area */ 
     101    total_size += 512; 
     102 
    91103    PJ_LOG(3, (THIS_FILE, "Benchmarking pool..")); 
    92104 
    93     // Warmup 
     105    /* Warmup */ 
    94106    pool_test_pool(); 
    95107    pool_test_malloc_free(); 
    … …  
    118130    } 
    119131 
    120     PJ_LOG(4, (THIS_FILE, "..LOOP count:                        %u", LOOP)); 
    121     PJ_LOG(4, (THIS_FILE, "..number of alloc/dealloc per loop:  %u", COUNT)); 
    122     PJ_LOG(4, (THIS_FILE, "..pool allocation/deallocation time: %u", pool_time)); 
    123     PJ_LOG(4, (THIS_FILE, "..malloc/free time:                  %u", malloc_time)); 
    124     PJ_LOG(4, (THIS_FILE, "..pool again, second invocation:     %u", pool_time2)); 
     132    PJ_LOG(4,(THIS_FILE,"..LOOP count:                        %u",LOOP)); 
     133    PJ_LOG(4,(THIS_FILE,"..number of alloc/dealloc per loop:  %u",COUNT)); 
     134    PJ_LOG(4,(THIS_FILE,"..pool allocation/deallocation time: %u",pool_time)); 
     135    PJ_LOG(4,(THIS_FILE,"..malloc/free time:                  %u",malloc_time)); 
     136    PJ_LOG(4,(THIS_FILE,"..pool again, second invocation:     %u",pool_time2)); 
    125137 
    126138    if (pool_time2==0) pool_time2=1; 
    … …  
    130142        best = pool_time2, worst = pool_time; 
    131143 
    132     PJ_LOG(3, (THIS_FILE, "..malloc Speedup best=%dx, worst=%dx",  
     144    PJ_LOG(3, (THIS_FILE, "..pool speedup over malloc best=%dx, worst=%dx",  
    133145                          (int)(malloc_time/best), 
    134146                          (int)(malloc_time/worst))); 

  • pjproject/trunk/pjlib/src/pjlib-test/sock.c

    r65 r433  
    6464#define TCP_PORT        (UDP_PORT+10) 
    6565#define BIG_DATA_LEN    9000 
     66#define ADDRESS         "127.0.0.1" 
     67#define A0              127 
     68#define A1              0 
     69#define A2              0 
     70#define A3              1 
     71 
    6672 
    6773static char bigdata[BIG_DATA_LEN]; 
    … …  
    7076static int format_test(void) 
    7177{ 
    72     pj_str_t s = pj_str("127.0.0.1"); 
    73     char *p; 
     78    pj_str_t s = pj_str(ADDRESS); 
     79    unsigned char *p; 
    7480    pj_in_addr addr; 
    7581    const pj_str_t *hostname; 
    … …  
    8288     
    8389    /* Check the result. */ 
    84     p = (char*)&addr; 
    85     if (p[0]!=127 || p[1]!=0 || p[2]!=0 || p[3]!=1) 
     90    p = (unsigned char*)&addr; 
     91    if (p[0]!=A0 || p[1]!=A1 || p[2]!=A2 || p[3]!=A3) { 
     92        PJ_LOG(3,("test", "  error: mismatched address. p0=%d, p1=%d, " 
     93                          "p2=%d, p3=%d", p[0] & 0xFF, p[1] & 0xFF,  
     94                           p[2] & 0xFF, p[3] & 0xFF)); 
    8695        return -15; 
     96    } 
    8797 
    8898    /* pj_inet_ntoa() */ 
    … …  
    98108    if (!hostname || !hostname->ptr || !hostname->slen) 
    99109        return -40; 
     110 
     111    PJ_LOG(3,("test", "....hostname is %.*s",  
     112              (int)hostname->slen, hostname->ptr)); 
    100113 
    101114    /* pj_gethostaddr() */ 
    … …  
    314327    dstaddr.sin_family = PJ_AF_INET; 
    315328    dstaddr.sin_port = pj_htons(UDP_PORT); 
    316     dstaddr.sin_addr = pj_inet_addr(pj_cstr(&s, "127.0.0.1")); 
     329    dstaddr.sin_addr = pj_inet_addr(pj_cstr(&s, ADDRESS)); 
    317330     
    318331    if ((rc=pj_sock_bind(ss, &dstaddr, sizeof(dstaddr))) != 0) { 
    319         app_perror("...bind error", rc); 
     332        app_perror("...bind error udp:"ADDRESS, rc); 
    320333        rc = -120; goto on_error; 
    321334    } 
    … …  
    325338    srcaddr.sin_family = PJ_AF_INET; 
    326339    srcaddr.sin_port = pj_htons(UDP_PORT-1); 
    327     srcaddr.sin_addr = pj_inet_addr(pj_cstr(&s, "127.0.0.1")); 
     340    srcaddr.sin_addr = pj_inet_addr(pj_cstr(&s, ADDRESS)); 
    328341 
    329342    if ((rc=pj_sock_bind(cs, &srcaddr, sizeof(srcaddr))) != 0) { 

  • pjproject/trunk/pjlib/src/pjlib-test/test.c

    r365 r433  
    4141                      PJ_LOG_HAS_MICRO_SEC; 
    4242 
     43int null_func() 
     44{ 
     45    return 0; 
     46} 
     47 
    4348int test_inner(void) 
    4449{ 
    … …  
    5964    } 
    6065     
    61     pj_dump_config(); 
     66    //pj_dump_config(); 
    6267    pj_caching_pool_init( &caching_pool, &pj_pool_factory_default_policy, 0 ); 
    6368 
    6469#if INCLUDE_ERRNO_TEST 
    6570    DO_TEST( errno_test() ); 
    66 #endif 
    67  
    68 #if INCLUDE_TIMESTAMP_TEST 
    69     DO_TEST( timestamp_test() ); 
    7071#endif 
    7172 
    … …  
    100101#if INCLUDE_RBTREE_TEST 
    101102    DO_TEST( rbtree_test() ); 
     103#endif 
     104 
     105#if INCLUDE_TIMESTAMP_TEST 
     106    DO_TEST( timestamp_test() ); 
    102107#endif 
    103108 

  • pjproject/trunk/pjlib/src/pjlib-test/test.h

    r365 r433  
    2222#include <pj/types.h> 
    2323 
    24 #define GROUP_LIBC                  1 
    25 #define GROUP_OS                    1 
    26 #define GROUP_DATA_STRUCTURE        1 
    27 #define GROUP_NETWORK               1 
    28 #define GROUP_FILE                  1 
     24#define GROUP_LIBC                  0 
     25#define GROUP_OS                    0 
     26#define GROUP_DATA_STRUCTURE        0 
     27#define GROUP_NETWORK               0 
     28#define GROUP_FILE                  0 
    2929 
    3030#define INCLUDE_ERRNO_TEST          GROUP_LIBC 
    … …  
    4949#define INCLUDE_TCP_IOQUEUE_TEST    GROUP_NETWORK 
    5050#define INCLUDE_IOQUEUE_PERF_TEST   GROUP_NETWORK 
    51 #define INCLUDE_IOQUEUE_UNREG_TEST  GROUP_NETWORK 
     51#define INCLUDE_IOQUEUE_UNREG_TEST  1   // GROUP_NETWORK 
    5252#define INCLUDE_FILE_TEST           GROUP_FILE 
    5353 
    … …  
    104104extern pj_status_t  app_socketpair(int family, int type, int protocol, 
    105105                                   pj_sock_t *server, pj_sock_t *client); 
     106extern int          null_func(void); 
    106107 
    107108//#define TRACE_(expr) PJ_LOG(3,expr) 
    108109#define TRACE_(expr) 
     110#define HALT(msg)   { PJ_LOG(3,(THIS_FILE,"%s halted",msg)); for(;;) sleep(1); } 
    109111 
    110112PJ_END_DECL 

  • pjproject/trunk/pjlib/src/pjlib-test/thread.c

    r351 r433  
    5353#define THIS_FILE   "thread_test" 
    5454 
    55 static int quit_flag=0; 
     55static volatile int quit_flag=0; 
     56 
     57#if 0 
     58#   define TRACE__(args)        PJ_LOG(3,args) 
     59#else 
     60#   define TRACE__(args) 
     61#endif 
     62 
    5663 
    5764/* 
    … …  
    6673    pj_thread_desc desc; 
    6774    pj_thread_t *this_thread; 
     75    unsigned id = *pcounter; 
    6876    pj_status_t rc; 
     77 
     78    TRACE__((THIS_FILE, "     thread %d running..", id)); 
    6979 
    7080    rc = pj_thread_register("thread", desc, &this_thread); 
    … …  
    91101        (*pcounter)++; 
    92102        //Must sleep if platform doesn't do time-slicing. 
    93         pj_thread_sleep(0); 
    94     } 
    95  
     103        //pj_thread_sleep(0); 
     104    } 
     105 
     106    TRACE__((THIS_FILE, "     thread %d quitting..", id)); 
    96107    return NULL; 
    97108} 
    … …  
    115126    quit_flag = 0; 
    116127 
     128    TRACE__((THIS_FILE, "    Creating thread 0..")); 
    117129    rc = pj_thread_create(pool, "thread", (pj_thread_proc*)&thread_proc, 
    118130                          &counter, 
    … …  
    126138    } 
    127139 
    128     pj_thread_sleep(500); 
     140    TRACE__((THIS_FILE, "    Main thread waiting..")); 
     141    pj_thread_sleep(1500); 
     142    TRACE__((THIS_FILE, "    Main thread resuming..")); 
    129143 
    130144    if (flags & PJ_THREAD_SUSPENDED) { 
    … …  
    145159    PJ_LOG(3,(THIS_FILE, "..waiting for thread to quit..")); 
    146160 
    147     pj_thread_sleep(500); 
     161    pj_thread_sleep(1500); 
    148162 
    149163    quit_flag = 1; 
    … …  
    176190    quit_flag = 0; 
    177191 
    178     pool = pj_pool_create(mem, NULL, 4096, 0, NULL); 
     192    pool = pj_pool_create(mem, NULL, 4000, 4000, NULL); 
    179193    if (!pool) 
    180194        return -10; 
    … …  
    184198    /* Create all threads in suspended mode. */ 
    185199    for (i=0; i<NUM_THREADS; ++i) { 
    186         counter[i] = 0; 
     200        counter[i] = i; 
    187201        rc = pj_thread_create(pool, "thread", (pj_thread_proc*)&thread_proc,  
    188202                              &counter[i],  
    … …  
    199213     * The purpose of this is to test whether all threads are suspended. 
    200214     */ 
     215    TRACE__((THIS_FILE, "    Main thread waiting..")); 
    201216    pj_thread_sleep(1000); 
     217    TRACE__((THIS_FILE, "    Main thread resuming..")); 
    202218 
    203219    /* Check that all counters are still zero. */ 
    204220    for (i=0; i<NUM_THREADS; ++i) { 
    205         if (counter[i] != 0) { 
     221        if (counter[i] > i) { 
    206222            PJ_LOG(3,(THIS_FILE, "....ERROR! Thread %d-th is not suspended!",  
    207223                      i)); 
    … …  
    212228    /* Now resume all threads. */ 
    213229    for (i=0; i<NUM_THREADS; ++i) { 
     230        TRACE__((THIS_FILE, "    Resuming thread %d [%p]..", i, thread[i])); 
    214231        rc = pj_thread_resume(thread[i]); 
    215232        if (rc != PJ_SUCCESS) { 
    … …  
    223240     * but it'll make user waits for longer for the test to finish. 
    224241     */ 
     242    TRACE__((THIS_FILE, "    Main thread waiting (5s)..")); 
    225243    pj_thread_sleep(5000); 
     244    TRACE__((THIS_FILE, "    Main thread resuming..")); 
    226245 
    227246    /* Signal all threads to quit. */ 
    … …  
    230249    /* Wait until all threads quit, then destroy. */ 
    231250    for (i=0; i<NUM_THREADS; ++i) { 
     251        TRACE__((THIS_FILE, "    Main thread joining thread %d [%p]..",  
     252                            i, thread[i])); 
    232253        rc = pj_thread_join(thread[i]); 
    233254        if (rc != PJ_SUCCESS) { 
    … …  
    235256            return -50; 
    236257        } 
     258        TRACE__((THIS_FILE, "    Destroying thread %d [%p]..", i, thread[i])); 
    237259        rc = pj_thread_destroy(thread[i]); 
    238260        if (rc != PJ_SUCCESS) { 
    … …  
    241263        } 
    242264    } 
     265 
     266    TRACE__((THIS_FILE, "    Main thread calculating time slices..")); 
    243267 
    244268    /* Now examine the value of the counters. 
    … …  
    264288    diff = (highest-lowest)*100 / ((highest+lowest)/2); 
    265289    if ( diff >= 50) { 
    266         PJ_LOG(3,(THIS_FILE, "...ERROR: thread didn't have equal timeslice!")); 
    267         PJ_LOG(3,(THIS_FILE, ".....lowest counter=%u, highest counter=%u, diff=%u%%", 
    268                              lowest, highest, diff)); 
     290        PJ_LOG(3,(THIS_FILE,  
     291                  "...ERROR: thread didn't have equal timeslice!")); 
     292        PJ_LOG(3,(THIS_FILE,  
     293                  ".....lowest counter=%u, highest counter=%u, diff=%u%%", 
     294                  lowest, highest, diff)); 
    269295        return -80; 
    270296    } else { 
    … …  
    274300    } 
    275301 
     302    pj_pool_release(pool); 
    276303    return 0; 
    277304} 

  • pjproject/trunk/pjlib/src/pjlib-test/timestamp.c

    r387 r433  
    189189 
    190190    /* Loop.. */ 
    191     for (i=0; i<1000000; ++i) 
    192         ; 
     191    for (i=0; i<1000000; ++i) { 
     192        /* Try to do something so that smart compilers wont 
     193         * remove this silly loop. 
     194         */ 
     195        null_func(); 
     196    } 
     197 
     198    sleep(0); 
    193199 
    194200    /* Mark end time. */ 
    … …  
    199205    PJ_LOG(3,(THIS_FILE, "....elapsed: %u usec", (unsigned)elapsed)); 
    200206 
    201     /* See if elapsed time is reasonable. */ 
    202     if (elapsed < 1 || elapsed > 100000) { 
     207    /* See if elapsed time is "reasonable".  
     208     * This should be good even on 50Mhz embedded powerpc. 
     209     */ 
     210    if (elapsed < 1 || elapsed > 1000000) { 
    203211        PJ_LOG(3,(THIS_FILE, "....error: elapsed time outside window (%u, " 
    204212                             "t1.u32.hi=%u, t1.u32.lo=%u, " 

  • pjproject/trunk/pjlib/src/pjlib-test/util.c

    r153 r433  
    2020#include <pjlib.h> 
    2121 
     22#define THIS_FILE "util.c" 
     23 
    2224void app_perror(const char *msg, pj_status_t rc) 
    2325{ 
    24     char errbuf[256]; 
     26    char errbuf[PJ_ERR_MSG_SIZE]; 
    2527 
    2628    PJ_CHECK_STACK(); 
    2729 
    2830    pj_strerror(rc, errbuf, sizeof(errbuf)); 
    29     PJ_LOG(1,("test", "%s: [pj_status_t=%d] %s", msg, rc, errbuf)); 
     31    PJ_LOG(3,("test", "%s: [pj_status_t=%d] %s", msg, rc, errbuf)); 
    3032} 
    3133 

  • pjproject/trunk/pjmedia/src/pjmedia-codec/gsm/config.h

    r241 r433  
    1010#define CONFIG_H 
    1111 
    12 /*efine SIGHANDLER_T    int             // * signal handlers are void   */ 
    13 /*efine HAS_SYSV_SIGNAL 1               // * sigs not blocked/reset?    */ 
     12//#define   SIGHANDLER_T        int     // * signal handlers are void   */ 
     13//#define   HAS_SYSV_SIGNAL     1       // * sigs not blocked/reset?    */ 
    1414 
    15 #define HAS_STDLIB_H    1               /* /usr/include/stdlib.h        */ 
    16 /*efine HAS_LIMITS_H    1               // * /usr/include/limits.h      */ 
    17 #define HAS_FCNTL_H     1               /* /usr/include/fcntl.h         */ 
    18 /*efine HAS_ERRNO_DECL  1               // * errno.h declares errno     */ 
     15#define     HAS_STDLIB_H        1       /* /usr/include/stdlib.h        */ 
     16//#define   HAS_LIMITS_H        1       // * /usr/include/limits.h      */ 
     17#define     HAS_FCNTL_H         1       /* /usr/include/fcntl.h         */ 
     18//#define   HAS_ERRNO_DECL      1       // * errno.h declares errno     */ 
    1919 
    20 #define HAS_FSTAT       1               /* fstat syscall                */ 
    21 #define HAS_FCHMOD      1               /* fchmod syscall               */ 
    22 #define HAS_CHMOD       1               /* chmod syscall                */ 
    23 #define HAS_FCHOWN      1               /* fchown syscall               */ 
    24 #define HAS_CHOWN       1               /* chown syscall                */ 
    25 /*efine HAS__FSETMODE   1               // * _fsetmode -- set file mode */ 
     20#define     HAS_FSTAT           1       /* fstat syscall                */ 
     21#define     HAS_FCHMOD          1       /* fchmod syscall               */ 
     22#define     HAS_CHMOD           1       /* chmod syscall                */ 
     23#define     HAS_FCHOWN          1       /* fchown syscall               */ 
     24#define     HAS_CHOWN           1       /* chown syscall                */ 
     25//#define   HAS__FSETMODE       1       // * _fsetmode -- set file mode */ 
    2626 
    27 #define HAS_STRING_H    1               /* /usr/include/string.h        */ 
    28 /*efine HAS_STRINGS_H   1               // * /usr/include/strings.h     */ 
     27#define     HAS_STRING_H        1       /* /usr/include/string.h        */ 
     28//#define   HAS_STRINGS_H       1       // * /usr/include/strings.h     */ 
    2929 
    30 #define HAS_UNISTD_H    1               /* /usr/include/unistd.h        */ 
    31 #define HAS_UTIME       1               /* POSIX utime(path, times)     */ 
    32 /*efine HAS_UTIMES      1               // * use utimes()       syscall instead */ 
    33 #define HAS_UTIME_H     1               /* UTIME header file            */ 
    34 /*efine HAS_UTIMBUF     1               // * struct utimbuf             */ 
    35 /*efine HAS_UTIMEUSEC   1               // * microseconds in utimbuf?   */ 
     30#define     HAS_UNISTD_H        1       /* /usr/include/unistd.h        */ 
     31#define     HAS_UTIME           1       /* POSIX utime(path, times)     */ 
     32//#define   HAS_UTIMES          1       // * use utimes() syscall instead*/ 
     33#define     HAS_UTIME_H         1       /* UTIME header file            */ 
     34//#define   HAS_UTIMBUF         1       // * struct utimbuf             */ 
     35//#define   HAS_UTIMEUSEC       1       // * microseconds in utimbuf?   */ 
    3636 
    3737 
    3838#endif  /* CONFIG_H */ 
     39 

  • pjproject/trunk/pjmedia/src/test/main.c

    r129 r433  
    1919#include "test.h" 
    2020 
     21  
     22/* Any tests that want to build a linked executable for RTEMS must include 
     23   this header to get a default config for the network stack. */ 
     24#if defined(PJ_RTEMS)  
     25#   include <bsp.h> 
     26#   include <rtems.h> 
     27#   include <rtems/rtems_bsdnet.h> 
     28#   include "../../../pjlib/include/rtems-network-config.h" 
     29#endif 
     30 
     31 
    2132int main() 
    2233{ 
Note: See TracChangeset for help on using the changeset viewer.