[ruby-core:56863] [ruby-trunk - Feature #8793] Ruby 2.0 and Threads under HPUX

Issue #8793 has been updated by [e-mail] (Michal Rokos).


On systems, I have a access to, the vps_pagesize is set to 16.

> /usr/sbin/kctune -v vps_pagesize
Tunable             vps_pagesize
Description         Default user page size (kBytes)
Module              vm
Current Value       16 [Default]
Value at Next Boot  16 [Default]
Value at Last Boot  16
Default Value       16
Constraints         vps_pagesize >= 4
                    vps_pagesize <= 4194304
Can Change          Immediately or at Next Boot

Regarding the _pthread_stack_info_np(), the API is
int _pthread_stack_info_np(pthread_t id, struct _pthread_stack_info *state);
and the _pthread_stack_info is
typedef struct _pthread_stack_info {
        int     stk_flags;

        /* Size of the stack */
        short   stk_stacksize_valid;
        size_t  stk_stacksize;

        /* Size of the guard page at the end of the stack */
        short   stk_guardsize_valid;
        size_t  stk_guardsize;

        /* Size of the Register Stack */
        short   stk_rsestacksize_valid;                                                                                                                       
        size_t  stk_rsestacksize;                                                                                                                             
                                                                                                                                                              
        /* Reserved for future use -- do not use, names WILL change */                                                                                        
        short   stk_reserved1_valid;                                                                                                                          
        size_t  stk_reserved1_size;                                                                                                                           
                                                                                                                                                              
        /* Address of the base of the stack */                                                                                                                
        void    *stk_stack_base;                                                                                                                              
                                                                                                                                                              
        /* Base of RSE BS.  Filled in only for IA64.  Do not use on PA. */                                                                                    
        void    *stk_rse_base;                                                                                                                                
                                                                                                                                                              
        /* Current stack pointer value */                                                                                                                     
        void    *stk_sp;                                                                                                                                      
                                                                                                                                                              
        /* Thread bsp.  Filled in only for IA64.  Do not use on PA. */                                                                                        
        void    *stk_bsp;                                                                                                                                     
                                                                                                                                                              
        /* Current program counter value */                                                                                                                   
        void    *stk_pc;                                                                                                                                      
                                                                                                                                                              
        /* Reserved for future use -- do not use, names WILL change */                                                                                        
        void    *stk_reserved[25];                                                                                                                            
} _pthread_stack_info_t;

But the obstacle with _pthread_stack_info_np() is that the polled thread 'id' has to be either stopped or suspended otherwise the _pthread_stack_info_np() is returning an error and does not provide values in 'state'. That is why i chose not to use is and use the _Asm_get_sp() instead.
----------------------------------------
Feature #8793: Ruby 2.0 and Threads under HPUX
https://bugs.ruby-lang.org/issues/8793#change-41410

Author: [e-mail] (Michal Rokos)
Status: Closed
Priority: Normal
Assignee: 
Category: 
Target version: 


Use of Threads under HPUX currently raise rb_eNotImpError ("ruby engine can initialize only in the main thread") since the STACKADDR_AVAILABLE is not available.

This brings basic support for the get_stack() under HPUX.

This patch also resolves issue under HPUX where signals usually cause the coredump since the stack size is too small.

It seems that the patch is valid not only for Ruby 2.0, but also for Ruby 1.9.


-- 
http://bugs.ruby-lang.org/