Signals in Multithreaded Application on Solaris 10.

HI All,
I need to know are the signal handlers are inherited by threads.
Assume I have defined a signal handler (assume for SIGCHLD )in main function before the creation of threads, and after that I create 5 threads. Can anyone please tell me if the signal SIGCHLD comes to any of the 5 threads will it be handled as signal handler defined earlier.
Any comments will be appreciated.
Regards,
Rahul.

What do you mean by 'linux application'? Right now, you'd have to recompile the program from source on Solaris or install a precompiled Solaris package.
After the release of project Janus, you might have some other choices to run Linux binaries directly on a Solaris (x86) machine.
Darren

Similar Messages

How to Debug C++ Multithreaded Application in Solaris

Hi All,
I am working in Solaris Sparc 5.8 Machine. I need to debug Multithreaded C++ Application in Unix Environment.
I am using dbx debugger.
Please explain me how to debug multithreaded applications. if possible please explain me with example.
Thanks in Advance.
Thanks & Regards,
Vasu

1. Look over the dbx manual that comes with Sun Studio. Dbx includes many features for debugging MT code.
2. If you have specific questions after reading the manual and trying out the features, ask them in the debugger forum:
http://forum.sun.com/forum.jspa?forumID=257

Pro*c multithreaded application has memory leak

Hi there,
I posted this message a week ago in OCI section, nobody answer me.
I am really curious if my application has a bug or the pro*c has a bug.
Anyone can compile the sample code and test it easily.
I made multithreaded application which queries dynamic SQL, it works.
But the memory leaks when i query the SQL statement.
The more memory leaks, the more i query the SQL statement, even same SQL
statement.
I check it with top, shell command.
My machine is SUN E450, Solaris 8. Oracle 9.2.0.1
Compiler : gcc (GCC) 3.2.2
I changed source code which is from
$(ORACLE_HOME)/precomp/demo/proc/sample10.pc
the sample10 doesn't need to be multithreaded. But i think it has to work
correctly if i changed it to multithreaded application.
the make file and source code will be placed below.
I have to figure out the problem.
Please help
Thanks in advance,
the make file is below
HOME = /user/jkku
ORA = $(ORACLE_HOME)
CC = gcc
PROC = proc
LC_INCL = -I$(HOME)/work/dbmss/libs/include
lc_incl = include=$(HOME)/work/dbmss/libs/include
SYS_INCL =
sys_incl =
ORA_INCL = -I. \
-I$(ORA)/precomp/public \
-I$(ORA)/rdbms/public \
-I$(ORA)/rdbms/demo \
-I$(ORA)/rdbms/pbsql/public \
-I$(ORA)/network/public \
-DSLMXMX_ENABLE -DSLTS_ENABLE -D_SVID_GETTOD
INCLUDES = $(LC_INCL) $(SYS_INCL) $(ORA_INCL)
includes = $(lc_incl) $(sys_incl)
LC_LIBS =
SYS_LIBS = -lpthread -lsocket -lnsl -lrt
ORA_LIBS = -L$(ORA)/lib/ -lclntsh
LIBS = $(LC_LIBS) $(SYS_LIBS) $(ORA_LIBS)
# Define C Compiler flags
CFLAGS += -D_Solaris64_ -m64
CFLAGS += -g -D_REENTRANT
# Define pro*c Compiler flags
PROCFLAGS += THREADS=YES
PROCFLAGS += CPOOL=YES
# Our object files
PRECOMPS = sample10.c
OBJS = sample10.o
.SUFFIXES: .o .c .pc
.c.o:
$(CC) -c $(CFLAGS) $(INCLUDES) $*.c
.pc.c:
$(PROC) $(PROCFLAGS) $(includes) $*.pc $*.c
all: sample10
sample10: $(PRECOMPS) $(OBJS)
$(CC) $(CFLAGS) -o sample10 $(OBJS) $(LIBS)
clean:
rm -rf *.o sample10 sample10.c
the source code is below which i changed the oracle sample10.pc to
multithreaded application.
Sample Program 10: Dynamic SQL Method 4
This program connects you to ORACLE using your username and
password, then prompts you for a SQL statement. You can enter
any legal SQL statement. Use regular SQL syntax, not embedded SQL.
Your statement will be processed. If it is a query, the rows
fetched are displayed.
You can enter multi-line statements. The limit is 1023 characters.
This sample program only processes up to MAX_ITEMS bind variables and
MAX_ITEMS select-list items. MAX_ITEMS is #defined to be 40.
#include <stdio.h>
#include <string.h>
#include <setjmp.h>
#include <sqlda.h>
#include <stdlib.h>
#include <sqlcpr.h>
/* Maximum number of select-list items or bind variables. */
#define MAX_ITEMS 40
/* Maximum lengths of the names of the
select-list items or indicator variables. */
#define MAX_VNAME_LEN 30
#define MAX_INAME_LEN 30
#ifndef NULL
#define NULL 0
#endif
/* Prototypes */
#if defined(__STDC__)
void sql_error(void);
int oracle_connect(void);
int alloc_descriptors(int, int, int);
int get_dyn_statement(void);
void set_bind_variables(void);
void process_select_list(void);
void help(void);
#else
void sql_error(/*_ void _*/);
int oracle_connect(/*_ void _*/);
int alloc_descriptors(/*_ int, int, int _*/);
int get_dyn_statement(/* void _*/);
void set_bind_variables(/*_ void -*/);
void process_select_list(/*_ void _*/);
void help(/*_ void _*/);
#endif
char *dml_commands[] = {"SELECT", "select", "INSERT", "insert",
"UPDATE", "update", "DELETE", "delete"};
EXEC SQL INCLUDE sqlda;
EXEC SQL INCLUDE sqlca;
EXEC SQL BEGIN DECLARE SECTION;
char dyn_statement[1024];
EXEC SQL VAR dyn_statement IS STRING(1024);
EXEC SQL END DECLARE SECTION;
EXEC ORACLE OPTION (ORACA=YES);
EXEC ORACLE OPTION (RELEASE_CURSOR=YES);
SQLDA *bind_dp;
SQLDA *select_dp;
/* Define a buffer to hold longjmp state info. */
jmp_buf jmp_continue;
char *db_uid="dbmuser/dbmuser@dbmdb";
sql_context ctx;
int err_sql;
enum{
SQL_SUCC=0,
SQL_ERR,
SQL_NOTFOUND,
SQL_UNIQUE,
SQL_DISCONNECT,
SQL_NOTNULL
int main()
int i;
EXEC SQL ENABLE THREADS;
EXEC SQL WHENEVER SQLERROR DO sql_error();
EXEC SQL WHENEVER NOT FOUND DO sql_not_found();
/* Connect to the database. */
if (connect_database() < 0)
exit(1);
EXEC SQL CONTEXT USE :ctx;
/* Process SQL statements. */
for (;;)
/* Allocate memory for the select and bind descriptors. */
if (alloc_descriptors(MAX_ITEMS, MAX_VNAME_LEN, NAME_LEN) != 0)
exit(1);
(void) setjmp(jmp_continue);
/* Get the statement. Break on "exit". */
if (get_dyn_statement() != 0)
break;
EXEC SQL PREPARE S FROM :dyn_statement;
EXEC SQL DECLARE C CURSOR FOR S;
/* Set the bind variables for any placeholders in the
SQL statement. */
set_bind_variables();
/* Open the cursor and execute the statement.
* If the statement is not a query (SELECT), the
* statement processing is completed after the
* OPEN.
EXEC SQL OPEN C USING DESCRIPTOR bind_dp;
/* Call the function that processes the select-list.
* If the statement is not a query, this function
* just returns, doing nothing.
process_select_list();
/* Tell user how many rows processed. */
for (i = 0; i < 8; i++)
if (strncmp(dyn_statement, dml_commands, 6) == 0)
printf("\n\n%d row%c processed.\n", sqlca.sqlerrd[2], sqlca.sqlerrd[2] == 1 ? '\0' : 's');
break;
/* Close the cursor. */
EXEC SQL CLOSE C;
/* When done, free the memory allocated for pointers in the bind and
select descriptors. */
for (i = 0; i < MAX_ITEMS; i++)
if (bind_dp->V != (char *) 0)
free(bind_dp->V);
free(bind_dp->I); /* MAX_ITEMS were allocated. */
if (select_dp->V != (char *) 0)
free(select_dp->V);
free(select_dp->I); /* MAX_ITEMS were allocated. */
/* Free space used by the descriptors themselves. */
SQLSQLDAFree(ctx, bind_dp);
SQLSQLDAFree(ctx, select_dp);
} /* end of for(;;) statement-processing loop */
disconnect_database();
EXEC SQL WHENEVER SQLERROR CONTINUE;
EXEC SQL COMMIT WORK RELEASE;
puts("\nHave a good day!\n");
return;
* Allocate the BIND and SELECT descriptors using sqlald().
* Also allocate the pointers to indicator variables
* in each descriptor. The pointers to the actual bind
* variables and the select-list items are realloc'ed in
* the set_bind_variables() or process_select_list()
* routines. This routine allocates 1 byte for select_dp->V
* and bind_dp->V, so the realloc will work correctly.
alloc_descriptors(size, max_vname_len, max_iname_len)
int size;
int max_vname_len;
int max_iname_len;
int i;
* The first sqlald parameter determines the maximum number of
* array elements in each variable in the descriptor. In
* other words, it determines the maximum number of bind
* variables or select-list items in the SQL statement.
* The second parameter determines the maximum length of
* strings used to hold the names of select-list items
* or placeholders. The maximum length of column
* names in ORACLE is 30, but you can allocate more or less
* as needed.
* The third parameter determines the maximum length of
* strings used to hold the names of any indicator
* variables. To follow ORACLE standards, the maximum
* length of these should be 30. But, you can allocate
* more or less as needed.
if ((bind_dp =
SQLSQLDAAlloc(ctx, size, max_vname_len, max_iname_len)) ==
(SQLDA *) 0)
fprintf(stderr,
"Cannot allocate memory for bind descriptor.");
return -1; /* Have to exit in this case. */
if ((select_dp =
SQLSQLDAAlloc(ctx, size, max_vname_len, max_iname_len)) == (SQLDA *)
0)
fprintf(stderr,
"Cannot allocate memory for select descriptor.");
return -1;
select_dp->N = MAX_ITEMS;
/* Allocate the pointers to the indicator variables, and the
actual data. */
for (i = 0; i < MAX_ITEMS; i++) {
bind_dp->I = (short *) malloc(sizeof (short));
select_dp->I = (short *) malloc(sizeof(short));
bind_dp->V = (char *) malloc(1);
select_dp->V = (char *) malloc(1);
return 0;
int get_dyn_statement()
char *cp, linebuf[256];
int iter, plsql;
for (plsql = 0, iter = 1; ;)
if (iter == 1)
printf("\nSQL> ");
dyn_statement[0] = '\0';
fgets(linebuf, sizeof linebuf, stdin);
cp = strrchr(linebuf, '\n');
if (cp && cp != linebuf)
*cp = ' ';
else if (cp == linebuf)
continue;
if ((strncmp(linebuf, "EXIT", 4) == 0) ||
(strncmp(linebuf, "exit", 4) == 0))
return -1;
else if (linebuf[0] == '?' ||
(strncmp(linebuf, "HELP", 4) == 0) ||
(strncmp(linebuf, "help", 4) == 0))
help();
iter = 1;
continue;
if (strstr(linebuf, "BEGIN") ||
(strstr(linebuf, "begin")))
plsql = 1;
strcat(dyn_statement, linebuf);
if ((plsql && (cp = strrchr(dyn_statement, '/'))) ||
(!plsql && (cp = strrchr(dyn_statement, ';'))))
*cp = '\0';
break;
else
iter++;
printf("%3d ", iter);
return 0;
void set_bind_variables()
int i, n;
char bind_var[64];
/* Describe any bind variables (input host variables) */
EXEC SQL WHENEVER SQLERROR DO sql_error();
bind_dp->N = MAX_ITEMS; /* Initialize count of array elements. */
EXEC SQL DESCRIBE BIND VARIABLES FOR S INTO bind_dp;
/* If F is negative, there were more bind variables
than originally allocated by sqlald(). */
if (bind_dp->F < 0)
printf ("\nToo many bind variables (%d), maximum is %d\n.",
-bind_dp->F, MAX_ITEMS);
return;
/* Set the maximum number of array elements in the
descriptor to the number found. */
bind_dp->N = bind_dp->F;
/* Get the value of each bind variable as a
* character string.
* C contains the length of the bind variable
* name used in the SQL statement.
* S contains the actual name of the bind variable
* used in the SQL statement.
* L will contain the length of the data value
* entered.
* V will contain the address of the data value
* entered.
* T is always set to 1 because in this sample program
* data values for all bind variables are entered
* as character strings.
* ORACLE converts to the table value from CHAR.
* I will point to the indicator value, which is
* set to -1 when the bind variable value is "null".
for (i = 0; i < bind_dp->F; i++)
printf ("\nEnter value for bind variable %.*s: ",
(int)bind_dp->C, bind_dp->S);
fgets(bind_var, sizeof bind_var, stdin);
/* Get length and remove the new line character. */
n = strlen(bind_var) - 1;
/* Set it in the descriptor. */
bind_dp->L = n;
/* (re-)allocate the buffer for the value.
sqlald() reserves a pointer location for
V but does not allocate the full space for
the pointer. */
bind_dp->V = (char *) realloc(bind_dp->V, (bind_dp->L + 1));
/* And copy it in. */
strncpy(bind_dp->V, bind_var, n);
/* Set the indicator variable's value. */
if ((strncmp(bind_dp->V, "NULL", 4) == 0) ||
(strncmp(bind_dp->V, "null", 4) == 0))
*bind_dp->I = -1;
else
*bind_dp->I = 0;
/* Set the bind datatype to 1 for CHAR. */
bind_dp->T = 1;
return;
void process_select_list()
int i, null_ok, precision, scale;
if ((strncmp(dyn_statement, "SELECT", 6) != 0) &&
(strncmp(dyn_statement, "select", 6) != 0))
select_dp->F = 0;
return;
/* If the SQL statement is a SELECT, describe the
select-list items. The DESCRIBE function returns
their names, datatypes, lengths (including precision
and scale), and NULL/NOT NULL statuses. */
select_dp->N = MAX_ITEMS;
EXEC SQL DESCRIBE SELECT LIST FOR S INTO select_dp;
/* If F is negative, there were more select-list
items than originally allocated by sqlald(). */
if (select_dp->F < 0)
printf ("\nToo many select-list items (%d), maximum is %d\n",
-(select_dp->F), MAX_ITEMS);
return;
/* Set the maximum number of array elements in the
descriptor to the number found. */
select_dp->N = select_dp->F;
/* Allocate storage for each select-list item.
sqlprc() is used to extract precision and scale
from the length (select_dp->L).
sqlnul() is used to reset the high-order bit of
the datatype and to check whether the column
is NOT NULL.
CHAR datatypes have length, but zero precision and
scale. The length is defined at CREATE time.
NUMBER datatypes have precision and scale only if
defined at CREATE time. If the column
definition was just NUMBER, the precision
and scale are zero, and you must allocate
the required maximum length.
DATE datatypes return a length of 7 if the default
format is used. This should be increased to
9 to store the actual date character string.
If you use the TO_CHAR function, the maximum
length could be 75, but will probably be less
(you can see the effects of this in SQL*Plus).
ROWID datatype always returns a fixed length of 18 if
coerced to CHAR.
LONG and
LONG RAW datatypes return a length of 0 (zero),
so you need to set a maximum. In this example,
it is 240 characters.
printf ("\n");
for (i = 0; i < select_dp->F; i++)
char title[MAX_VNAME_LEN];
/* Turn off high-order bit of datatype (in this example,
it does not matter if the column is NOT NULL). */
sqlnul ((unsigned short *)&(select_dp->T), (unsigned short
*)&(select_dp->T), &null_ok);
switch (select_dp->T)
case 1 : /* CHAR datatype: no change in length
needed, except possibly for TO_CHAR
conversions (not handled here). */
break;
case 2 : /* NUMBER datatype: use sqlprc() to
extract precision and scale. */
sqlprc ((unsigned int *)&(select_dp->L), &precision,
&scale);
/* Allow for maximum size of NUMBER. */
if (precision == 0) precision = 40;
/* Also allow for decimal point and
possible sign. */
/* convert NUMBER datatype to FLOAT if scale > 0,
INT otherwise. */
if (scale > 0)
select_dp->L = sizeof(float);
else
select_dp->L = sizeof(int);
break;
case 8 : /* LONG datatype */
select_dp->L = 240;
break;
case 11 : /* ROWID datatype */
case 104 : /* Universal ROWID datatype */
select_dp->L = 18;
break;
case 12 : /* DATE datatype */
select_dp->L = 9;
break;
case 23 : /* RAW datatype */
break;
case 24 : /* LONG RAW datatype */
select_dp->L = 240;
break;
/* Allocate space for the select-list data values.
sqlald() reserves a pointer location for
V but does not allocate the full space for
the pointer. */
if (select_dp->T != 2)
select_dp->V = (char *) realloc(select_dp->V,
select_dp->L + 1);
else
select_dp->V = (char *) realloc(select_dp->V,
select_dp->L);
/* Print column headings, right-justifying number
column headings. */
/* Copy to temporary buffer in case name is null-terminated */
memset(title, ' ', MAX_VNAME_LEN);
strncpy(title, select_dp->S, select_dp->C);
if (select_dp->T == 2)
if (scale > 0)
printf ("%.*s ", select_dp->L+3, title);
else
printf ("%.*s ", select_dp->L, title);
else
printf("%-.*s ", select_dp->L, title);
/* Coerce ALL datatypes except for LONG RAW and NUMBER to
character. */
if (select_dp->T != 24 && select_dp->T != 2)
select_dp->T = 1;
/* Coerce the datatypes of NUMBERs to float or int depending on
the scale. */
if (select_dp->T == 2)
if (scale > 0)
select_dp->T = 4; /* float */
else
select_dp->T = 3; /* int */
printf ("\n\n");
/* FETCH each row selected and print the column values. */
EXEC SQL WHENEVER NOT FOUND GOTO end_select_loop;
for (;;)
EXEC SQL FETCH C USING DESCRIPTOR select_dp;
/* Since each variable returned has been coerced to a
character string, int, or float very little processing
is required here. This routine just prints out the
values on the terminal. */
for (i = 0; i < select_dp->F; i++)
if (*select_dp->I < 0)
if (select_dp->T == 4)
printf ("%-*c ",(int)select_dp->L+3, ' ');
else
printf ("%-*c ",(int)select_dp->L, ' ');
else
if (select_dp->T == 3) /* int datatype */
printf ("%*d ", (int)select_dp->L,
*(int *)select_dp->V);
else if (select_dp->T == 4) /* float datatype */
printf ("%*.2f ", (int)select_dp->L,
*(float *)select_dp->V);
else /* character string */
printf ("%-*.*s ", (int)select_dp->L,
(int)select_dp->L, select_dp->V);
printf ("\n");
end_select_loop:
return;
void help()
puts("\n\nEnter a SQL statement or a PL/SQL block at the SQL> prompt.");
puts("Statements can be continued over several lines, except");
puts("within string literals.");
puts("Terminate a SQL statement with a semicolon.");
puts("Terminate a PL/SQL block (which can contain embedded
semicolons)");
puts("with a slash (/).");
puts("Typing \"exit\" (no semicolon needed) exits the program.");
puts("You typed \"?\" or \"help\" to get this message.\n\n");
int connect_database()
err_sql = SQL_SUCC;
EXEC SQL WHENEVER SQLERROR DO sql_error();
EXEC SQL WHENEVER NOT FOUND DO sql_not_found();
EXEC SQL CONTEXT ALLOCATE :ctx;
EXEC SQL CONTEXT USE :ctx;
EXEC SQL CONNECT :db_uid;
if(err_sql != SQL_SUCC){
printf("err => connect database(ctx:%ld, uid:%s) failed!\n", ctx, db_uid);
return -1;
return 1;
int disconnect_database()
err_sql = SQL_SUCC;
EXEC SQL WHENEVER SQLERROR DO sql_error();
EXEC SQL WHENEVER NOT FOUND DO sql_not_found();
EXEC SQL CONTEXT USE :ctx;
EXEC SQL COMMIT WORK RELEASE;
EXEC SQL CONTEXT FREE:ctx;
return 1;
void sql_error()
printf("err => %.*s", sqlca.sqlerrm.sqlerrml, sqlca.sqlerrm.sqlerrmc);
printf("in \"%.*s...\'\n", oraca.orastxt.orastxtl, oraca.orastxt.orastxtc);
printf("on line %d of %.*s.\n\n", oraca.oraslnr, oraca.orasfnm.orasfnml,
oraca.orasfnm.orasfnmc);
switch(sqlca.sqlcode) {
case -1: /* unique constraint violated */
err_sql = SQL_UNIQUE;
break;
case -1012: /* not logged on */
case -1089:
case -3133:
case -1041:
case -3114:
case -3113:
/* �6�Ŭ�� shutdown�ǰų� �α�� °� �ƴҶ� ��b�� õ� */
/* immediate shutdown in progress - no operations are permitted */
/* end-of-file on communication channel */
/* internal error. hostdef extension doesn't exist */
err_sql = SQL_DISCONNECT;
break;
case -1400:
err_sql = SQL_NOTNULL;
break;
default:
err_sql = SQL_ERR;
break;
EXEC SQL CONTEXT USE :ctx;
EXEC SQL WHENEVER SQLERROR CONTINUE;
EXEC SQL ROLLBACK WORK;
void sql_not_found()
err_sql = SQL_NOTFOUND;

Hi Jane,
What version of Berkeley DB XML are you using?
What is your operating system and your hardware platform?
For how long have been the application running?
What is your current container size?
What's set for EnvironmentConfig.setThreaded?
Do you know if containers have previously not been closed correctly?
Can you please post the entire error output?
What's the JDK version, 1.4 or 1.5?
Thanks,
Bogdan

Using time() function in multithreaded application

I am using time() function in a multithreaded application with NULL argument for getting current time.
Some time it's observed that we get a time one minute earlier than current time (3600 seconds).
Is there a problem in the usage of the function?
I am using expression : currenttime = time(NULL);
I had seen some people using following way - time(&currenttime );
Will above two behaves differently in multithreaded environment?
[I am using Sun C++ 5.5 compiler on Solaris 8]

How do you compare actual time against the time seen by your threads? If your threads are printing the value from time(2) to stdout, it's possible that you're seeing an artifact of thread scheduling and/or output buffering.
I really doubt that you have a concurrency problem, but anyway make sure that you include the -mt option on your compile line:
CC -mt blahblahblah...

Calling ipseckey from multithreaded application

Hello
My multithreaded network C++ application calls Solaris ipseckey utility concurrently while deleting/adding IPSEC SA without any additional synchronisation.
Application can call concurrently in threads constructions like
FILE * fp = popen("/usr/sbin/ipseckey -f <file with commands>","r");
pclose(fp);
Does anybody knows if it is safe to do it in such way without synchronisation?
I didn't find inter-process synchronisation in ipseckey code opposite to ipsecconf utility where such synchronisation is provided by lock file.
I am suspecting that ipseckey is not "Multiple Process" safe.
Sometimes during application running I see system panic with stack like below.
SunOS xxx 5.10 Generic_139555-08 sun4v sparc SUNW,T5140
Apr 6 12:43:26 WS_same_subnet unix: [ID 783603 kern.notice] Deadlock: cycle in blocking chain
Apr 6 12:43:26 WS_same_subnet unix: [ID 100000 kern.notice]
Apr 6 12:43:26 WS_same_subnet genunix: [ID 723222 kern.notice] 000002a10203eeb0 genunix:turnstile_block+630 (1271800, 3b, 60010b3ea70, 182b110, 0, 0)
Apr 6 12:43:26 WS_same_subnet genunix: [ID 179002 kern.notice] %l0-3: 000000000182b110 0000000000000000 0000060013db0550 00000600134a6d08
Apr 6 12:43:26 WS_same_subnet %l4-7: 00000300044c0be0 0000000000000001 0000000000000000 0000000000000000
Apr 6 12:43:26 WS_same_subnet genunix: [ID 723222 kern.notice] 000002a10203ef60 unix:mutex_vector_enter+428 (1872380, 2, 60010b3ea70, fff999198400ec63, 300044c0be0, 0)
Apr 6 12:43:26 WS_same_subnet genunix: [ID 179002 kern.notice] %l0-3: 00000000018f1fe0 0000000000000000 0000000000000000 0000000000000000
Apr 6 12:43:26 WS_same_subnet %l4-7: 00000300044c0be0 0000000000000001 000000000182b148 000000000182b140
Apr 6 12:43:26 WS_same_subnet genunix: [ID 723222 kern.notice] 000002a10203f010 ipsecah:get_ipsa_pair+1a4 (6001c7312c0, 60010b3c000, 60010b3ea68, 6001087e9b0, 6001bc77628, 2)
Apr 6 12:43:26 WS_same_subnet genunix: [ID 179002 kern.notice] %l0-3: 0000060010b3c060 000000007bf1f420 000006001c7312dc 0000000000000000
Apr 6 12:43:26 WS_same_subnet %l4-7: 000000000000006f 0000060010b3c068 0000060010b3ea70 000000000b07016f
Apr 6 12:43:26 WS_same_subnet genunix: [ID 723222 kern.notice] 000002a10203f0e0 ipsecah:sadb_delget_sa+13c (600115785c0, 60015db68f0, 6001087e990, 2a10203f29c, 600126b54b8, 13)
Apr 6 12:43:26 WS_same_subnet genunix: [ID 179002 kern.notice] %l0-3: 0000000000000001 0000000000000000 0000000000000000 00000300011d61b0
Apr 6 12:43:26 WS_same_subnet %l4-7: 00000300011d6440 0000000000000004 0000060015db68f8 0000000000000027
Apr 6 12:43:26 WS_same_subnet genunix: [ID 723222 kern.notice] 000002a10203f1e0 ipsecesp:esp_parse_pfkey+cc (3, 3, 6001087e940, 60015db68f0, f8, 6001c7312b0)
Apr 6 12:43:26 WS_same_subnet genunix: [ID 179002 kern.notice] %l0-3: 0000060015db6a50 000000007dfaae03 ffffffffffffffff 000000007dfaae04
Apr 6 12:43:26 WS_same_subnet %l4-7: 000000007dfaac00 00000600115785c0 000000007bbb32c4 000000007bbb3000
Apr 6 12:43:26 WS_same_subnet genunix: [ID 723222 kern.notice] 000002a10203f2a0 unix:putnext+218 (600126b56a8, 600126b55b0, 600115785c0, 100, 600126b5320, 0)
Apr 6 12:43:26 WS_same_subnet genunix: [ID 179002 kern.notice] %l0-3: 0000000000000000 0000000000000000 0000000000000000 0000000000005350
Apr 6 12:43:26 WS_same_subnet %l4-7: 000000000000010d 00000000019831d8 000000007bbb35dc fffffd5efdfc6000
Apr 6 12:43:26 WS_same_subnet genunix: [ID 723222 kern.notice] 000002a10203f350 keysock:keysock_parse+270 (60019e0f5f0, 600137bd200, 290, 0, 30001b04f40, 600164ed0a0)
Apr 6 12:43:26 WS_same_subnet genunix: [ID 179002 kern.notice] %l0-3: 0000060010b54a80 000006001c7312b0 0000000000000048 000002a10203f408
Apr 6 12:43:26 WS_same_subnet %l4-7: 000000007bbcffe0 000000007bbcfc00 0000000000000003 0000000000000003
Apr 6 12:43:26 WS_same_subnet genunix: [ID 723222 kern.notice] 000002a10203f4e0 unix:putnext+218 (600109a3868, 600164ed0a0, 6001cb61140, 100, 6001bde6988, 0)
Apr 6 12:43:26 WS_same_subnet genunix: [ID 179002 kern.notice] %l0-3: 0000000000000000 0000000000000000 0000000000000000 0000000000005590
Apr 6 12:43:26 WS_same_subnet %l4-7: 000000000000010d 0000000070000ef0 000000007bbd0678 fffffd5efdfc6000
Apr 6 12:43:26 WS_same_subnet genunix: [ID 723222 kern.notice] 000002a10203f590 genunix:strput+1d8 (600190044f0, 6001cb61140, 6da1, 6001cb61140, 60013c72fd0, 0)
Apr 6 12:43:26 WS_same_subnet genunix: [ID 179002 kern.notice] %l0-3: 000006001bde6988 0000000000000004 0000000000000000 0000000000000000
Apr 6 12:43:26 WS_same_subnet %l4-7: 000006001c76e580 00000600134a6d08 0000000000000000 0000000000000000
Apr 6 12:43:26 WS_same_subnet genunix: [ID 723222 kern.notice] 000002a10203f790 genunix:kstrputmsg+33c (6001a371040, 60015f60fc0, 2a10203fa98, 6001cb61140, 2, 0)
Apr 6 12:43:26 WS_same_subnet genunix: [ID 179002 kern.notice] %l0-3: 0000000000000003 0000000000000000 0000000000000004 00000600190044f0
Apr 6 12:43:26 WS_same_subnet %l4-7: 0000060019004570 0000000000000000 0000000000000000 0000000000000000
Apr 6 12:43:26 WS_same_subnet genunix: [ID 723222 kern.notice] 000002a10203f870 sockfs:sosend_svc+94 (6001c175320, 2a10203fa98, 3, 0, 61, 0)
Apr 6 12:43:26 WS_same_subnet genunix: [ID 179002 kern.notice] %l0-3: 0000000000000008 000002a10203f928 0000000000000001 0000000000000004
Apr 6 12:43:26 WS_same_subnet %l4-7: 0000000000000001 000006001c175340 0000000000000021 0000000000000048
Apr 6 12:43:26 WS_same_subnet genunix: [ID 723222 kern.notice] 000002a10203f930 genunix:fop_write+20 (6001a371040, 2a10203fa98, 0, 60012743560, 0, 133da18)
Apr 6 12:43:26 WS_same_subnet genunix: [ID 179002 kern.notice] %l0-3: 0000000000000048 0000000000002420 0000000000002000 0000000000000009
Apr 6 12:43:26 WS_same_subnet %l4-7: 000006001086a080 0000060010883500 00000600108839e8 00000000022169e2
Apr 6 12:43:26 WS_same_subnet genunix: [ID 723222 kern.notice] 000002a10203f9e0 genunix:write+268 (5, 8058, 600192090e0, 48, 3, 1)
Apr 6 12:43:26 WS_same_subnet genunix: [ID 179002 kern.notice] %l0-3: 0000000000000000 000006001a371040 0000000000000000 0000000000008b10
Apr 6 12:43:26 WS_same_subnet %l4-7: 0000000000000048 0000000000000128 0000000000000000 0000000000000003
Apr 6 12:43:26 WS_same_subnet unix: [ID 100000 kern.notice]
Apr 6 12:43:26 WS_same_subnet genunix: [ID 672855 kern.notice] syncing file systems...

Thank you
I selected the following threads from mdb output
000003000475ee40 600133c9120 600115535d0 1 58 60010b58200
PC: turnstile_block+0x600 CMD: /usr/sbin/ipseckey -f /tmp/ipsecWPXbJe4xN
stack pointer for thread 3000475ee40: 2a101e3c6b1
[ 000002a101e3c6b1 turnstile_block+0x600() ]
mutex_vector_enter+0x428()
get_ipsa_pair+0x1a4()
sadb_delget_sa+0x13c()
esp_parse_pfkey+0xcc()
putnext+0x218()
keysock_parse+0x270()
putnext+0x218()
strput+0x1d8()
kstrputmsg+0x33c()
sosend_svc+0x94()
fop_write+0x20()
write+0x268()
syscall_trap32+0xcc()
000003000443f5e0 6001352f1c0 60015c4d778 1 49 60010b56068
PC: panicsys+0x48 CMD: /usr/sbin/ipseckey -f /tmp/ipsecVPXaJe4xN
stack pointer for thread 3000443f5e0: 2a101f0c6d1
turnstile_block+0x630()
mutex_vector_enter+0x428()
sadb_delget_sa+0x1a4()
esp_parse_pfkey+0xcc()
putnext+0x218()
keysock_parse+0x270()
putnext+0x218()
strput+0x1d8()
kstrputmsg+0x33c()
sosend_svc+0x94()
fop_write+0x20()
write+0x268()
syscall_trap32+0xcc()
Using of PF_KEY will be our next step for better performance.

Multithread application is crashing random in malloc, free, new or delete

Hi Gurus,
Operating System:
SunOS 5.8 Generic_108528-04 sun4u sparc SUNW,Ultra-80
C++:
WorkShop Compilers 5.0 98/12/15 C++ 5.0
I'm a multithread application using "pthread" and compiled with "-mt -xtarget=ultra -xarch=v9".
My problem is that the server is crashing in differents points (random).
The server can be running without problems, but other times the server crashs immediately.
Always, the server is crashing in the functions "new", "delete", "malloc" or "free".
Normally two functions appears in the top of the stack:
realfree and mallocunlocked with SIGBUS or SIGSEGV.
So, I don't know if I need to install a pacth or is a problem in my server. The problem is that the server can run "n" times correctly and other times crashs with SIGBUS or SIGSEGV in the above functions doing exactly the same.
Could you help me ? Any idea ?
Do you need the stack ?
Thanks and Merry Christmas,
Andres

Hi Susan,
Here is the threads and stack with the rtc_error_stack on:
(/opt/SUNWspro/bin/../WS5.0/bin/sparcv9/dbx) where
current thread: t@23
[1] realfree(0x100341190, 0xffffffff7c3bb608, 0x100341330, 0xffffffff7c3aeef8, 0x100341190, 0x63), at 0xffffffff7c249140
[2] freeunlocked(0xffffffff7c3bb4f0, 0xffffffff7c3aeef8, 0x1003415a0, 0x1002a34c0, 0x1002a34b0, 0x0), at 0xffffffff7c249928
[3] free(0x1003415a0, 0x1001d9e10, 0x1, 0xffffffff7c3aeef8, 0x100252900, 0x31), at 0xffffffff7c24986c
=>[4] JS_free(cx = 0x1002a2ff0, p = 0x1003415a0), line 1450 in "jsapi.c"
[5] js_DestroyScope(cx = 0x1002a2ff0, scope = 0x1003415a0), line 475 in "jsscope.c"
[6] js_DestroyObjectMap(cx = 0x1002a2ff0, map = 0x1003415a0), line 1554 in "jsobj.c"
[7] js_DropObjectMap(cx = 0x1002a2ff0, map = 0x1003415a0, obj = 0x10033d9a0), line 1571 in "jsobj.c"
[8] js_FinalizeObject(cx = 0x1002a2ff0, obj = 0x10033d9a0), line 1770 in "jsobj.c"
[9] js_GC(cx = 0x1002a2ff0, gcflags = 0), line 1217 in "jsgc.c"
[10] js_ForceGC(cx = 0x1002a2ff0), line 943 in "jsgc.c"
[11] JS_GC(cx = 0x1002a2ff0), line 1641 in "jsapi.c"
[12] DestroyJsEngine(jsRuntime = 0x1003358b0, jsContext = 0x1002a2ff0), line 149 in "jsengine.cpp"
[13] JSWorkerThread(lpContextHandle = 0x1002c46a0), line 2329 in "pccwebserver.cpp"
(/opt/SUNWspro/bin/../WS5.0/bin/sparcv9/dbx) threads
t@1 a l@1 ?() sleep on 0x1001d78f0 in __lwp_sema_wait()
t@2 b l@2 ?() running in __signotifywait()
t@3 b l@3 ?() running in __lwp_sema_wait()
t@4 ?() sleep on (unknown) in reapwait()
t@5 a l@4 ArgusThread() running in soaccept()
t@6 a l@5 PollThread() running in _poll()
t@7 a l@6 PollThread() running in _poll()
t@8 a l@7 WorkerThread() sleep on 0x1002d8868 in __lwp_sema_wait()
t@9 a l@8 WorkerThread() sleep on 0x1002d8868 in __lwp_sema_wait()
t@10 a l@9 WorkerThread() sleep on 0x1002d8868 in __lwp_sema_wait()
t@11 a l@10 WorkerThread() sleep on 0x1002d8868 in __lwp_sema_wait()
t@12 a l@11 WorkerThread() sleep on 0x1002d8868 in __lwp_sema_wait()
t@13 a l@12 WorkerThread() sleep on 0x1002d8868 in __lwp_sema_wait()
t@14 a l@13 WorkerThread() sleep on 0x1002d8868 in __lwp_sema_wait()
t@15 a l@14 WorkerThread() sleep on 0x1002d8868 in __lwp_sema_wait()
t@16 a l@15 WorkerThread() sleep on 0x1002d8868 in __lwp_sema_wait()
t@17 a l@16 WorkerThread() sleep on 0x1002d8868 in __lwp_sema_wait()
t@18 a l@18 WorkerThread() sleep on 0x1002d8868 in __lwp_sema_wait()
t@19 a l@17 WorkerThread() sleep on 0x1002d8868 in __lwp_sema_wait()
t@20 a l@19 ListenThread() running in soaccept()
t@21 a l@20 ListenThread() running in soaccept()
t@22 a l@21 ListenThread() running in soaccept()
*> t@23 a l@22 JSWorkerThread() signal SIGBUS in realfree()
t@24 a l@23 JSWorkerThread() sleep on 0x1002c46e8 in __lwp_sema_wait()
t@25 a l@24 JSWorkerThread() sleep on 0x1002c46e8 in __lwp_sema_wait()
t@25 a l@24 JSWorkerThread() sleep on 0x1002c46e8 in __lwp_sema_wait()
t@26 a l@26 JSWorkerThread() sleep on 0x1002c46e8 in __lwp_sema_wait()
t@27 a l@27 JSWorkerThread() sleep on 0x1002c46e8 in __lwp_sema_wait()
t@28 a l@25 JSWorkerThread() sleep on 0x1002c46e8 in __lwp_sema_wait()
t@29 a l@28 JSWorkerThread() sleep on 0x1002c46e8 in __lwp_sema_wait()
t@30 a l@29 JSWorkerThread() sleep on 0x1002c46e8 in __lwp_sema_wait()
t@31 a l@30 JSWorkerThread() sleep on 0x1002c46e8 in __lwp_sema_wait()
t@32 a l@31 JSWorkerThread() sleep on 0x1002c46e8 in __lwp_sema_wait()
t@33 a l@32 UnixFtThread() running in soaccept()
t@34 b l@34 cotimerset() running in __lwp_sema_wait()
(/opt/SUNWspro/bin/../WS5.0/bin/sparcv9/dbx)
Any idea ??
Andres

How to configure ENV and DB for multithreaded application?

Hi,
From document, I know DB_THREAD must be checked for both ENV and DB, but , I don't know which one is best choice for multithreaded application while facing DB_INIT_LOCK and DB_INIT_CDB. In my application, there maybe multi readers and writers at the same time, should I use DB_INIT_LOCK instead of DB_INIT_CDB? what other flags should I use?
DB_INIT_CDB provides multiple reader/single writer access while DB_INIT_LOCK should be used when multiple processes or threads are going to be reading and writing a Berkeley DB database.
Thanks for your seggestions and answers.

Thanks for the explanation,
The Berkeley DB Concurrent Data Store product
allows for multiple reader/single writer access
to a database. This means that at any point in time,
there may be either multiple readers accessing a
database or a single writer updating the database.
Berkeley DB Concurrent Data Store is intended for
applications that need support for concurrent updates
to a database that is largely used for reading.
If you are looking to support multiple readers and
multiple writers then take a look at the Transactional
Data Store product
(http://download.oracle.com/docs/cd/E17076_02/html/programmer_reference/transapp.html)
In this case the Environment is typically opened with:
DB_INIT_MPOOL, DB_INIT_LOCK, DB_INIT_LOG, and DB_INIT_TXN.
Let me know if I missed any of your question.
Thanks,
Sandra

Multithreading issue on Solaris 8 branded zone

Hi,
We are facing a multithreading problem in Solaris 8 container (branded zone) on Solaris 10.
The core file shows 2 LWPs for a single thread.
First LWP
(dbx) lwp
current LWP ($lwp) is l@1403
(dbx) print this->m_ThreadId->m_IdImpl.m_PosixId
this->m_ThreadId.m_IdImpl.m_PosixId = 1404U
Second LWP
(dbx) lwp
current LWP ($lwp) is l@1404
(dbx) print this->m_ThreadId->m_IdImpl.m_PosixId
this->m_ThreadId.m_IdImpl.m_PosixId = 1404U
Another point to note is that dbx returns 'MT support is disabled' for this program even though it has been built using the -mt option. The dbx version is Sun Dbx Debugger 7.5 2005/10/13.
As far as I have read, the Solaris 8 branded zone uses the alternate T2 thread library. Note also that this program is linked with the alternate thread library @ /usr/lib/lwp.
This alternate thread library is supposed to use the 1:1 thread model.
Can someone explain why are we then seeing 2 LWPs for a single thread ?
Thanks,
Best regards,
Raj Iyer

This error messages are output by
cssd which is a input method of Japanese.
If you don't use Japanese input method cs00, you can stop it by following method.
# /etc/init.d/loc.ja.cssd stop
# mv /etc/rc2.d/S90loc.ja.cssd /etc/rc2.d/_S90loc.ja.cssd

Dup2 after fork in multithreaded application

I am working on a multithreaded application (C++) that must create several
Java processes and capture their output though pipes.
For a single threaded application, I know it is possible to call dup2 (in the child)
after the fork to set up the proper connections.
I am aware that it is not safe to make particular function calls between a fork
and an exec. Is dup2 a call that is known to be safe?
If not, is there a better alternative?
Thanks.

I'm using Oracle 10g2 on Windows Server 2003 on a Dell PowerEdge 1850 server.
Both threads run the same code. Each thread performs multiple database queries though.
This query is performed first:
update my_table set my_data_processed='true' where my_data_processed='false' and rownum=1 returning my_index into :x
Then the query with the getBlob is performed with <some_number> = my_index.
Some background info: I have a lot of data in my_table that needs a very slow operation performed on the my_data blob in each row. I will eventually run this application on multiple servers in parallel and need a way to determine the next row that hasn't been processed yet then process it.
The table is
create table my_table (
my_index int,
my_data_processed varchar(10),
my_data blob
-Glen

Migrating Legacy Applications to Solaris 10 Containers

Hi, Good Day,
We have some customers who are keen to migrate their legacy banking systems to run on Solaris 10 containers. We intend to assess the feasibility of the project.
Kindly advice the considerations/potential pitfalls(if any) of running legacy Solaris 8 applications on Solaris 10 containers. Kindly advice those types of applications that cannot run on Solaris 10 containers?
What kind of information should we extract from the customer to understand these considerations?
Thank-you and Best Regards,
Siong Guan

Oracle migration workbench solve only the technical point of the migration. That won't solve the data mapping you have to define on your own.
Data mapping is the most important task of a migration, totally depending of the source and target systems. You need expertise on both of them and discuss with the business and functional experts people.
Then, and only after defining the data mapping, you can go for the technical migration.
Nicolas.

PersistenceManager Patterns for Multithreaded Applications

Hi,
I'm looking for a good way, how to use Kodo JDO in a multithread application
(actually Tomcat ;). The most easy thing is perhaps, to use only one
persistence
manager for the entire application, i.e. for all threads. Another solution
might be,
to create a PersistenceManager for each HTTP request. I don't like the
solution,
to have one PeristenceManager per session, because I expect thousands
concurrent
users. What I'm concerned with is the number of data base connections in
this
case.
So my question to you is, what pattern do you use in your web applications?
When do you create and close the PersistenceManagers to free resources?
Has anybody alreay tried different patterns and compared the performance?
Is there something like a best practice?
Michael

The other nice thing about the filter is that it should be easy to
selectivly store and retrieve the PM in a user's session if they have a
longer running transaction that spans multiple requests.
So far, I've simply been passing the PM to each service method, although I
don't particularliy like that approach. I haven't had time to try anything
different yet and it isn't TOO bad, although I have a few ideas:
1. The hashtable method you mentioned. I see there is a "Registry" pattern
in the "Patterns of Enterprise Application Architecture" book I'm currently
reading, but haven't gotten to it yet. I think it is close to what you
mentioned.
2. Retrieve the PM through JNDI. I don't know, however, if I can set up a
PM in JNDI the way that the CurrentTransaction JNDI lookup works with
container managed transactions.
"Michael" <[email protected]> wrote in message
news:[email protected]...
I've never used a servlet filter before but I must say that is the most
elegant approach I've seen, thanks for sharing that. How do you pass thePM
to the service layer? Do you store it in a hashtable with the current
thread as a key or do you pass it in to each service method?
Thanks,
Michael
"Nathan Voxland" <[email protected]> wrote in message
news:[email protected]...
We've created the PersistenceManager in a filter and attached it to the
request object. That way, the persistence manager can be accessed fromthe
Struts Action, JSP Page, and anything else we do, plus we don't have to
worry about closing it because it is closed by the filter after
everything
is done (Even if an exception is thrown)
Here is the code:
public void doFilter(final ServletRequest request, final ServletResponse
response, FilterChain chain) throws IOException, ServletException {
PersistenceManager pm = getPersistenceManager();
request.setAttribute(JDO_PERSISTENCE_MANAGER, pm);
try {
chain.doFilter(request, response);
} finally {
if (pm.currentTransaction().isActive()) {
pm.currentTransaction().rollback();
pm.close();
"Michael" <[email protected]> wrote in message
news:[email protected]...
I currently doing exactly this: getting a persistence manager at the
beginning of a jsp page and close it at the end of the jsp page.
When you use <jsp:include ...>, you must be careful not to close the
persistence manager to early. I do it like this:
This sounds like a good approach, especially the hashtable with the
thread
as the key. The only issue I see is if you create the PM in the JSPpage,
often an Action is executed before the JSP is called. This is why I
was
thinking of creating the PM in the struts request processor, it'salways
called for every request.

Consuming a jms queue from a multithread application

Hi
Thank you for reading my post.
I have an application which shuld consume message of a queue.
my application is multithread and what i want to know is:
- How i can ask queue to remove a message after my thread finished its work with the message, by this way i can ensure that if my thread face an exception after it read the message my message will not lose.
- As it is multithread application, How i can ensure that a message is not delivered to two or more thread? is there any way to consume the messages in a synchronized way?
Will synchronized access restrict the performance?
Thanks

This is running in a J2DK environment. For my thread pool, I just copied one from a Sun tutorial on multi-threading then modified it. I creaed a seperate package with three classes. Here is my thread pooling package. I basically use a Vector to hold threads when they are not working. And you can set a limit as to the max number of active threads.
package threadpooling;
* @author cferris
* This class is simple to wrap the runnable
* thread for the worker thread around other
* needed parameters like salon id and source.
public class TaskWrapper {
// Define the needed instance fields.
public Runnable taskAtHand = null;
public String taskType = "";
    // Overloaded constructor.
    public TaskWrapper(Runnable task) {
      // Just set the runnable
      taskAtHand = task;
      taskType = "WorkerThread";
    } // of overloaded contructor
    // Overloaded constructor.
    public TaskWrapper(Runnable task, String taskType) {
      // Just set the instance fields
      taskAtHand = task;
      this.taskType = taskType;
    } // of overloaded contructor
package threadpooling;
* @author cferris
* This class is for tracking the number of
* active threads so we don't go over the set
* limit. This class basically synchronizes
* the methods that update the active thread
* counter.
import java.util.*;
public class ThreadPool {
// Define the instance fields.
//   First define instance fields for the
//   management of the thread pools - pm.
protected Vector poolOfThreads = new Vector();
private static LinkedList taskQueue = new LinkedList();
private static int poolSize = 0;
private static boolean pmAvailable = true;
private static boolean daemon = false;
public   static boolean shutDown = false;
//   Instance field for the management of
//   the threads - tm.
private static int activeThreads = 0;
private static int maxReached = 0;
private static int numTimesReached = 0;
private static boolean tmAvailable = true;
// Define constants
private static final int MAX_LIMIT_DEFAULT = 32;
    // The constructor.
    public ThreadPool() {
      this(MAX_LIMIT_DEFAULT, false);
    } // of constructor
    // Overload the constructor with max number of active jobs.
    public ThreadPool(int poolSize, boolean daemon) {
      this.poolSize = poolSize;
      this.daemon = daemon;
      poolOfThreads = new Vector();
      taskQueue = new LinkedList();
      salonTracker = new Vector();
      // Load up and initialize the threads.
      for (int i=0; i < poolSize; i++) {
          Thread thread = new WorkerThread(this, i);
          thread.setDaemon(daemon);
          thread.start();
          poolOfThreads.add(thread);
    } // of overloaded constructor
    // Overload this method to allow just the runnable task.
    public void assignWork(Runnable work) {
      // Create the wrapper
      TaskWrapper wrapper = new TaskWrapper(work, "A task");
      assignWork(wrapper);
    } // of overloaded assignWork
    // Push a unit of work (work thread) on the the worker thread.
    public synchronized void assignWork(TaskWrapper work) {
      // First increament the active thread count.
      increment();
      // Wait until we can access the linked list
      try {
          if (!pmAvailable)
              wait();
      } catch(InterruptedException e) { }
      pmAvailable = false;
      notifyAll();
      taskQueue.addLast(work);
      pmAvailable = true;
      notifyAll();
    } // of assignWork
    // Get the next unit of work (work thread).
    public synchronized TaskWrapper getNextWorkAssignment() {
      // Wait until we can access the linked list
      try {
          if (!pmAvailable)
              wait();
      } catch(InterruptedException e) { }
      pmAvailable = false;
      notifyAll();
      TaskWrapper nextTask;
      if (!taskQueue.isEmpty())
          nextTask = (TaskWrapper)taskQueue.removeFirst();
      else
          nextTask = null;
      pmAvailable = true;
      notifyAll();
      return nextTask;
    } // of getNextWorkAssignment
    // Return the number of tasks waiting on the work queue.
    public synchronized int workWaiting() {
      // Wait until we can access the linked list
      try {
          if (!pmAvailable)
              wait();
      } catch(InterruptedException e) { }
      pmAvailable = false;
      notifyAll();
      int qSize = taskQueue.size();
      pmAvailable = true;
      notifyAll();
      return qSize;
    } // of workWaiting
    // Wait until all the tasks have been completed.
    public void waitForCompletion() {
      int prev = 0;
      // Continue checking untill all the threads have
      // completed and been removed.
      while(!poolOfThreads.isEmpty()) {
         // Lets record the difference
         if (poolOfThreads.size() != prev) {
             System.out.println("waiting for " + poolOfThreads.size() + " to complete");
             prev = poolOfThreads.size();
         // Loop through the thread pool and check each thread.
         for (int t = 0; t < poolOfThreads.size(); t++)
              if (!((WorkerThread)poolOfThreads.get(t)).working)
                  // This thead is done so remove it.
                  poolOfThreads.remove(t);
      } // of while
    } // waitForCompletion
    // Set the max number of allow threads.
    public synchronized void setPoolSize(int newLimit) {
      // just set the limit.
      // Check if available
      while (!tmAvailable) {
         try {
           wait();
         catch(InterruptedException ie) {
           System.exit(5);
      // Ok, lock the object while we update it.
      tmAvailable = false;
      notifyAll();
      poolSize = newLimit;
      // Reset the max counters/trackers too
      maxReached = 0;
      numTimesReached = 0;
      // Create additional threads in the pool if needed
      if (poolSize > poolOfThreads.size())
          // Load up and initialize the threads.
          for (int i = poolOfThreads.size(); i < poolSize; i++) {
              Thread thread = new WorkerThread(this, i);
              thread.start();
              poolOfThreads.add(thread);
      // Done, now release the object.
      tmAvailable = true;
      notifyAll();
    } // of setPoolSize.
    // The method to increment thread counter.
    private synchronized void increment() {
      // Check if available
      while (!tmAvailable) {
         try {
           wait();
         catch(InterruptedException ie) {
           // logger.fatal("Synchronized error in ThreadPool ");
           // logger.fatal("Error message is: " + ie.getMessage());
           System.exit(5);
      // Ok, lock the object while we update it.
      tmAvailable = false;
      notifyAll();
      activeThreads++;
      // Check if this is the highest number of threads
      // that has been active, if not then set so.
      if (activeThreads > maxReached)
          maxReached = activeThreads;
      if (activeThreads == poolSize)
          numTimesReached++;
      // Done, now release the object.
      tmAvailable = true;
      notifyAll();
    } // of increment
    // The method to increment thread counter.
    public synchronized void decrement() {
      // Check if available
      while (!tmAvailable) {
         try {
           wait();
         catch(InterruptedException ie) {
           // logger.fatal("Synchronized error in ThreadPool ");
           // logger.fatal("Error message is: " + ie.getMessage());
           System.exit(5);
      // Ok, lock the object while we update it.
      tmAvailable = false;
      notifyAll();
      activeThreads--;
      // Done, now release the object.
      tmAvailable = true;
      notifyAll();
    } // of decrement
    // A method to determine if the maximum number of active
    // threads has been reached.
    public synchronized boolean limitNotReached() {
      boolean limit = false;
      // Check if available
      while (!tmAvailable) {
         try {
           wait();
         catch(InterruptedException ie) {
           // logger.fatal("Synchronized error in ThreadPool.");
           // logger.fatal("Error message is: " + ie.getMessage());
           System.exit(5);
      // Ok, lock the object while we update it.
      tmAvailable = false;
      notifyAll();
      if (activeThreads < poolSize)
         limit = true;
      // Done, now release the object.
      tmAvailable = true;
      notifyAll();
      return limit;
    } // of limitNotReached
    // A method to return the number of active threads.
    public synchronized int currentNum() {
      // Check if available
      while (!tmAvailable) {
         try {
           wait();
         catch(InterruptedException ie) {
           // logger.fatal("Synchronized error in ThreadPool");
           // logger.fatal("Error message is: " + ie.getMessage());
           System.exit(5);
      // Ok, lock the object while we update it.
      tmAvailable = false;
      notifyAll();
      int numberOf = activeThreads;
      // Done, now release the object.
      tmAvailable = true;
      notifyAll();
      return numberOf;
    } // of currentNum
package threadpooling;
* @author cferris
*   This is the work thread that receives the
*   taskes or unit of work that make up the
*   thread pool.
public class WorkerThread extends Thread {
// Define need instance fields.
public boolean working = true;
public int id = 0;
private int pauseFactor = 1;
// The thread pool that this object belongs to.
public ThreadPool owner;
// Define the constructor for the seperate thread.
public WorkerThread(ThreadPool pooler, int id) {
    owner = pooler;
    this.id = id;
} // of contructor
// Wait for work or for system shutdown.
public void run() {
    // Define the work object.
    TaskWrapper unitOfWork = null;
    // Wait for work or until system is shutting down.
    do {
       unitOfWork = owner.getNextWorkAssignment();
       if (unitOfWork != null) {
           // First set name and then add salon to watch list.
           String taskName = unitOfWork.taskType + "-" + id;
           setName(taskName);
        // System.out.println("Starting thread - " + getName());
           unitOfWork.taskAtHand.run();
           // Done, now adjust tracker and reset the pause factor.
           owner.decrement();
           pauseFactor = 1;
       else {
           // No work so pause a bit
           try {
               sleep(150 * pauseFactor);
           } catch (InterruptedException e) { }
           // If consecutively pausing because of no work then
           // increase the pause time up to a point.
           if (pauseFactor < 49)
               pauseFactor++;
    } while (!owner.shutDown);
    // Set indicator this thread in the pool is done.
    working = false;
} // of run
}To use the thread pool just create a static instance of the ThreadPool in your main class
private static ThreadPool threadPool = new ThreadPool(getMaxThreads(), useDaemon());Then to launch a new thread use this.
    if (runOnSeperateThread()) {
        WriteTransThread task = new WriteTransThread(messasge);
        // Add to the thread pool.
        threadPool.assignWork(new TaskWrapper(task, "my thread"));
private boolean runOnSeperateThread() {
    // First check if mutli threading is turned on
    // and if there are open threads.
    if (multiThreadingOn && threadPool.limitNotReached())
        // Yes, there are open threads.
        return true;
    // Check if we can wait for an open thread.
    if (!multiThreadingOn || !waitForOpenThread)
        // No multi threading or waiting allowed.
        return false;
    // OK, wait for an open thread, wait for up
    // to 90 seconds.
    int j = 0;
    do {
        try {
            // Wait 1/2 a second.
            Thread.sleep(500);
        } catch(InterruptedException ignore) { };
        // Check again for an optn thread.
        if (threadPool.limitNotReached())
            // Ok to run on separate thread.
            return true;
        // Increament counter and wait again.
        j++;
    } while(j < 180);
    // If we got this far then we've waited long enough.
    logger.warn("Reached limit on waiting for an open thread in the pool");
    return false;
} // of runOnSeperateThreadThe WriteTransThread is a class that will extract the message body and write out its data to a table.
Last, before you end your program make sure all the threads have competed by calling the following.
// If multi-threading is activated then this method will
// wait for them to complete before returning. The
// max wait time is 300 secs or 5 minutes.
private void waitForThreadsToComplete(String message) {
    // First check for multi threading.
    if (prop.useMultiThread() && (threadPool.currentNum() > 0)) {
        int limit = 0;
        // Some threads are still active, wait
        logger.info("Waiting for threads to complete before " + message
                  + " current thread count is " + threadPool.currentNum());
        do {
           limit++;
           try {
               Thread.sleep(500); // Sleep 1/2 a sec.
           } catch(InterruptedException ie) { } // Ignore the error for now.
           // Max waith is 300 sec or 5 min.
        } while ((threadPool.currentNum() > 0) && (limit < 600));
} // of waitForThreadsToComplete

I/O Exception in multithreading application

I have a multithreading application that utilizes OracleDataSource with explicit caching enabled. The cache is sized to keep as little opened connections as possible. It works fine but under heavy load I'm getting
I/O Exception: The Network Adapter could not establish the connection(SQL Code: 17002, SQL State: + 08006) (java.sql.SQLRecoverableException)
oracle.jdbc.driver.SQLStateMapping:101 (null)
I suppose that this is due to numerous concurrent calls to Oracle listener which the last is unable to process. The database itself is OK as when opening the same number (and even times more) of connections sequentially we get no errors.
Is it possible to slow down OracleDataSource somehow to dose new physical connection requests?
ConnectionWaitTimeout is not an option as it dilays ALL connection requests thus after this timeout listener accepts that calls again with the same rate.
Actually I'm ready to give up some speed to get better reliability.

It means the file is not there. Check to make sure the file is in the specified location, if it is, check the spelling.

Generating 32 bit applications on Solaris 9 / UltraSparc III+

Hallo.
I wish to generate some 32 bit applications on Solaris 9 and UltraSparc III+ platform. I need to do that as my process have to dinamically link a 32 bit shared object previosuly installed by another software (to be precise, the library is an "ELF 32-bit MSB dynamic lib SPARC Version 1, dynamically linked, not stripped").
After my generation, some executables that runned perfectly on my previous UNIX SCO platform, now crash when exiting.
Moreover I find out that my master process correctly launches the execution of a slave process (I traced the values of the paramters passed to the execv() system call) but the slave process immediatly exits because it gets wrong parameters (I found out that in the main() function within the slave program, the argc parameter is 0 (!!) that sounds really really strange!!)
Is there anyone able to help me?
For your information, when I compile my objects I use the following options:
cc -g -xc99=none -xtarget=ultra -xchar -c <source>
and when I link them I use the following:
/usr/ccs/bin/ld -z defs -z verbose -dy -B dynamic -o <processname> <object list> <shared library> -lm -lc
Doing so, both the master and slave process are "ELF 32-bit MSB executable SPARC32PLUS Version 1, V8+ Required, UltraSPARC1 Extensions Required, dynamically linked, not stripped"
Thank you in advance!!
Gianni

Why do you want to make your own link lines?
Use cc to link, not ld. You ask for trouble.
I made the following program:
int main(int argc, char **argv) { return argc;}
% cc -c t.c
Then used your link line to link it:
% /usr/ccs/bin/ld -z defs -z verbose -dy -B dynamic -o a.out t.o -ln -lc
% a.out
Segmentation fault (core dumped)
Use cc to link. Do not try to use ld. Or if you really, really think you have to use ld yourselves, run cc -### ... first to se what link line it uses, and try to make the variation you need yourselves. But all kind of options to ld can also be given to cc.

Technical query w.r.t running C++ applications on Solaris 9.

Hi,
We have an C++ application which is compiled with Sun compiler 5.3 which comes along with Forte6 Update2. The application is compiled and linked on Solaris 9 platform. Will there be any issues while running this application on Solaris 8? Are applications built on Solaris 9 safely run on Solaris 8?
Thanks,
Vinay

Sun supports moving old programs and binary files forward from old Solaris and compiler versions to be used with newer Solaris and compiler versions, but not the reverse. (Supporting the reverse would mean never providing new or improved features.)
If you build an application on one Solaris version, you can run it on that version or later versions. In general it will NOT run on earlier Solaris versions.
SImilarly if you create an object file (.o, .a, .so) on one Solaris version, you cannot use that file on an earlier Solaris version.
When you plan to deploy an application on different versions of Solaris, you must build the entire application, including shared libraries that are part of the application, on the earliest version of Solaris that you intend to support.

Signals in Multithreaded Application on Solaris 10.

Similar Messages

Maybe you are looking for