Есть идея создать враппер для системных вызовов типа select(),nanosleep() в котором вместо timeval && timespec будеть юзатся int64_t(long long)

И что это упростит? =) Помоему не надо. Через стуктуры типа timeval временные промежутки задавать имхо удобнее.

>Через стуктуры типа timeval временные промежутки задавать имхо удобне

да если их до и после никак не обрабатывать. А если тебе по результатам gettimeofday надо вычислить паузу для select() то получиш непрогребаемый код

Пока что меня на ето. Может у когото есть получше идеи??

/** $Id: time64.h,v 1.3 2005/01/12 09:39:09 cvv Exp $                                                                                        
 *                                                                                                                                           
 *  Copyright (c) 2005 Business Computer Servive, Ltd.                                                                                       
 *  Written by Vitaly Chernookiy <cvv@email.zp.ua>                                                                                           
 */                                                                                                                                          
#ifndef __time64_h                                                                                                                           
#define __time64_h                                                                                                                           
#ifdef __cplusplus                                                                                                                           
extern "C" {                                                                                                                                 
#endif                                                                                                                                       
//----------------------------------------------------                                                                                       
                                                                                                                                             
                                                                                                                                             
#include <stdint.h>                                                                                                                          
                                                                                                                                             
typedef enum {t64_sec=0,t64_msec,t64_usec,t64_nsec}time64_type_t;                                                                            
                                                                                                                                             
typedef int64_t  time64_t;                                                                                                                   
typedef int64_t mtime64_t;                                                                                                                   
typedef int64_t utime64_t;                                                                                                                   
typedef int64_t ntime64_t;                                                                                                                   
                                                                                                                                             
 time64_t  time64(void);                                                                                                                     
mtime64_t mtime64(void);                                                                                                                     
utime64_t utime64(void);                                                                                                                     
ntime64_t ntime64(void);                                                                                                                     
                                                                                                                                             
 sleep64( time64_t time);                                                                                                                    
msleep64(mtime64_t time);                                                                                                                    
usleep64(utime64_t time);                                                                                                                    
nsleep64(ntime64_t time);                                                                                                                    
                                                                                                                                             
int  poll64(struct pollfd *ufds, unsigned int nfds,  time64_t time);                                                                         
int mpoll64(struct pollfd *ufds, unsigned int nfds, mtime64_t time);                                                                         
int upoll64(struct pollfd *ufds, unsigned int nfds, utime64_t time);                                                                         
int npoll64(struct pollfd *ufds, unsigned int nfds, ntime64_t time);                                                                         
                                                                                                                                             
int  select64(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,  time64_t time);                                                  
int mselect64(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, mtime64_t time);                                                  
int uselect64(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, utime64_t time);                                                  
int nselect64(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, ntime64_t time);                                                  
                                                                                                                                             
int  pselect64(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,  time64_t time, const sigset_t *sigmask);                        
int mpselect64(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, mtime64_t time, const sigset_t *sigmask);                        
int upselect64(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, utime64_t time, const sigset_t *sigmask);                        
int npselect64(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, ntime64_t time, const sigset_t *sigmask);                        
//----------------------------------------------------                                                                                       
#ifdef __cplusplus                                                                                                                           
}                                                                                                                                            
#endif                                                                                                                                       
#endif /* __time64_h */                                                                                                                      

Что-то я не очень тебя понимаю.. Если вызывает сложность вычитание и сложение структур timeval, могу дать функции.

>Если вызывает сложность вычитание и сложение структур timeval

на мой взгляд вычитание и сложение структур на С приводит к непрогребаемому коду. делать етоже с long long намного приятней/удобней. Я немного попробовал очень понравилось и решил предложить другим.

Принципиальным моментом здеся есть смесь РАЗНЫХ структур а именно timeval && timespec

>могу дать функции.

А то их сложно написать.

Функции select и nanosleep выполняют абсолютно разные действия! Зачем нужно чтобы им передавались указатели на структуры одного типа?

Если уж это так сильно надо, то используйте
pselect. В нее передается указатель на timespec. Говорят она не очень переносима. Я в это не очень верю, но эту функцию не так сложно написать самому(на случай непереносимости =).

>на мой взгляд вычитание и сложение структур на С приводит к >непрогребаемому коду. делать етоже с long long намного >приятней/удобней. Я немного попробовал очень понравилось и решил >предложить другим.

Непрогребаемому??? У меня это заняло 3-5 строчек, со всеми проверками.
Один раз написав такие функции их можно использовать всегда. Хотя это требуется не так часто имхо..

С long long приятней. но помоему все таки не так удобно. Точнее имхо совсем неудобно.

>Точнее имхо совсем неудобно

А обьяснить можно???

у меня местами переход на ll привёл к уменьшению размера кода в разы (гдето 2.5)

>А обьяснить можно???

Не знаю, как вам, но мне просто так проще задавать: секунды, микросекунды, все в отдельныйх полях структуры. Все по отдельности.

>у меня местами переход на ll привёл к уменьшению размера кода в разы >(гдето 2.5)

Сокращения кода я не вижу.

Насчет удобства это мое имхо. Я просто не понимаю чем это будет проще, сложностей я не вижу.

К тому же что делать с функцией setitimer? и функциями которые принимают похожие параметры? Придется переделывать много чего.

PS. Если бы это было чем-то выгодно то в POSIX (вероятно)отбросили бы эти timeval, и заменили на u_int64_t. Там любят минимальность. Хотя это и не обязательно. =))

PSPS. Если есть какая-то задача где это действительно проще - то я с вами соглашусь. Но имхо это может быть проще, только в случае, когда в других местах программы время задается как скаляр, а не структура. А если временные интервалы используются только всякими select, то нафиг это надо.