The Y2K38 problem refers to an issue that will occur in systems that store time as a 32-bit signed integer representing seconds since January 1st, 1970. This will overflow on January 19th, 2038 when the number becomes too large for 32 bits. After this point, times will wrap around and be interpreted as dates in 1901 instead of future dates, causing systems to fail. The solution is to update systems to use 64-bit integers or unsigned 32-bit integers to store time and avoid this overflow.

1. For Documentation and Downloads Visit

2. CURRENT TECHNOLOGYCurrently all software and systems that store system time as a signed 32bit integer, and interpret this number as the number of seconds since 00:00:00 January 1, 1970.THE Y2K38 PROBLEM The latest time that can be represented this way is 03:14:07 UTC on Tuesday, 19 January 2038. Times beyond this moment will "wrap around" and be stored internally as a negative number, which these systems will interpret as a date in 1901 rather than 2038.

3. AN INSTANCE

4. WHERE’S THE PROBLEM The structure time_t is a value type which stores time in a 32-bit signed integer. It stores the time as number of seconds elapsed since January 1, 1970.

5. So it is capable of representing time which can be addressed within total of 231 seconds.

6. According to this, the latest time that it can store is 03:14:07 UTC, Tuesday, January 19, 2038. After this time, the sign bit of the 32-bit signed integer will be set and it will represent a negative number. WRAP AROUND DATE The time is stored as number of seconds elapsed since 1st January 1970, this negative number will be added to compute the time as per the POSIX standards. But this being a negative number it will calculate the time by subtracting this many seconds from 1st January 1970 which will eventually generate a historical date-time which will cause the applications to fail. This time will be Friday, December 1901 and is called the wrap-around date

7. AN INSTANCE

8. WHY IS THE PROBLEMY2K38 problems arise from programs not allocating enough bits to internal time.

9. Unix internal time is commonly stored in a data structure using a long int containing the number of seconds since 1970.

10. In a 32-bit machine, this value is sufficient to store time up to 18-jan-2038. After this date, 32-bit clocks will overflow and return erroneous values such as 32-dec-1969 or 13-dec-1901. 2,147,483,647

11. An examle C programint main (int argc, char **argv) { time_t t; t = (time_t) 1000000000; printf ("%d, %s", (int) t, asctime (gmtime (&t))); t = (time_t) (0x7FFFFFFF); printf ("%d, %s", (int) t, asctime (gmtime (&t))); t++; printf ("%d, %s", (int) t, asctime (gmtime (&t))); return 0; }

12. OUTPUT1000000000, Sun Sep 9 01:46:40 2001

13. 2147483647, Tue Jan 19 03:14:07 2038

14. 2147483648, Fri Dec 13 20:45:52 1901LIVE EXAMPLEIn May 2006, reports surfaced of an early Y2038 problem in the AOL Server software. The software would specify that a database request should "never" time out by specifying a timeout date one billion seconds in the future. One billion seconds (just over 31 years 251 days and 12 hours) after 21:27:28 on 12 May 2006 is beyond the 2038 cutoff date, so after this date, the timeout calculation overflowed and calculated a timeout date that was actually in the past, causing the software to crash.[THE COUNTDOWN BEGINS32-bit CPUs may be obsolete in desktop computers and servers by 2038.

15. Most programs maybe affected in or very close to 2038.

16. Hardware, such as clock circuits, which has adopted the Unix time convention, may also be affected if 32-bit registers are used.

17. This will likely cause problems for users of these systems due to erroneous calculationsSimilar ProblemsIBM PC hardware suffers from the Year 2116 problem. For a PC, the beginning of time starts at January 1, 1980, and increments by seconds in an unsigned 32-bit integer in a manner similar to UNIX time. By 2116, the integer overflows.

18. Windows NT uses a 64-bit integer to track time. However, it uses 100 nanoseconds as its increment and the beginning of time is January 1, 1601, so NT suffers from the Year 2184 problem. SOLUTIONRe-define the time_t structure as 64-bit.

19. Change time_t from 32-bit signed to 32-bit unsigned.

20. Shift from 32-bit systems to 64-bit systems.ANY QUERIES?ANY QUERIES?For Documentation and Downloads Visit