Search code examples
linuxkernelperformancectype

Linux kernel 0.0.1 vs 2.6.36, "ctype.h", whats the difference?

How efficient is linux kernel 2.6.36 from 0.0.1

0.0.1:

  1. I understand, in this version, Linus has assigned the value of c(input variable to a function) to a temp variable and operate on that temp variable inside the function and return the temp variable.

  2. This happens in tolower/toupper functions.

2.6.36:

  1. Here in tolower/toupper he changed it.
  2. ctype is const.
  3. New function ismask is written.

What I want to know?:

Why these changes has been made?, what good it brought home?

I have listed out the ctype.h files in the kernel versions of 0.0.1 and 2.6.36, respectively.

 **** ctype.h, linux-0.01 *****

    #ifndef _CTYPE_H
    #define _CTYPE_H

    #define _U      0x01    /* upper */
    #define _L      0x02    /* lower */
    #define _D      0x04    /* digit */
    #define _C      0x08    /* cntrl */
    #define _P      0x10    /* punct */
    #define _S      0x20    /* white space (space/lf/tab) */
    #define _X      0x40    /* hex digit */
    #define _SP     0x80    /* hard space (0x20) */

    extern unsigned char _ctype[];
    extern char _ctmp;

    #define isalnum(c) ((_ctype+1)[c]&(_U|_L|_D))
    #define isalpha(c) ((_ctype+1)[c]&(_U|_L))
    #define iscntrl(c) ((_ctype+1)[c]&(_C))
    #define isdigit(c) ((_ctype+1)[c]&(_D))
    #define isgraph(c) ((_ctype+1)[c]&(_P|_U|_L|_D))
    #define islower(c) ((_ctype+1)[c]&(_L))
    #define isprint(c) ((_ctype+1)[c]&(_P|_U|_L|_D|_SP))
    #define ispunct(c) ((_ctype+1)[c]&(_P))
    #define isspace(c) ((_ctype+1)[c]&(_S))
    #define isupper(c) ((_ctype+1)[c]&(_U))
    #define isxdigit(c) ((_ctype+1)[c]&(_D|_X))

    #define isascii(c) (((unsigned) c)<=0x7f)
    #define toascii(c) (((unsigned) c)&0x7f)   

    #define tolower(c) (_ctmp=c,isupper(_ctmp)?_ctmp+('a'+'A'):_ctmp)
    #define toupper(c) (_ctmp=c,islower(_ctmp)?_ctmp+('A'-'a'):_ctmp)


    #endif
# 
****** ctype.h, linux-2.6.36 *******

#ifndef _LINUX_CTYPE_H
#define _LINUX_CTYPE_H

/*
* NOTE! This ctype does not handle EOF like the standard C
* library is required to.
*/

#define _U      0x01    /* upper */
#define _L      0x02    /* lower */
#define _D      0x04    /* digit */
#define _C      0x08    /* cntrl */
#define _P      0x10    /* punct */
#define _S      0x20    /* white space (space/lf/tab) */
#define _X      0x40    /* hex digit */
#define _SP     0x80    /* hard space (0x20) */

extern const unsigned char _ctype[];

#define __ismask(x) (_ctype[(int)(unsigned char)(x)])

#define isalnum(c)      ((__ismask(c)&(_U|_L|_D)) != 0)
#define isalpha(c)      ((__ismask(c)&(_U|_L)) != 0)
#define iscntrl(c)      ((__ismask(c)&(_C)) != 0)
#define isdigit(c)      ((__ismask(c)&(_D)) != 0)
#define isgraph(c)      ((__ismask(c)&(_P|_U|_L|_D)) != 0)
#define islower(c)      ((__ismask(c)&(_L)) != 0)
#define isprint(c)      ((__ismask(c)&(_P|_U|_L|_D|_SP)) != 0)
#define ispunct(c)      ((__ismask(c)&(_P)) != 0)
/* Note: isspace() must return false for %NUL-terminator */
#define isspace(c)      ((__ismask(c)&(_S)) != 0)
#define isupper(c)      ((__ismask(c)&(_U)) != 0)
#define isxdigit(c)     ((__ismask(c)&(_D|_X)) != 0)

#define isascii(c) (((unsigned char)(c))<=0x7f)
#define toascii(c) (((unsigned char)(c))&0x7f)

static inline unsigned char __tolower(unsigned char c)
{
       if (isupper(c))
               c -= 'A'-'a';
       return c;
}

static inline unsigned char __toupper(unsigned char c)
{
       if (islower(c))
               c -= 'a'-'A';
       return c;
}

#define tolower(c) __tolower(c)
#define toupper(c) __toupper(c)

#endif
Solution

  • Why these changes has been made?, what good it brought home?

    For one, you don't have to define a ctemp variable in code calling isupper any longer, thereby reducing lines of code. It also obviously avoids leaking implementation details.