IPC and synchronizatio

multi threading pthreads

system calls

socket programming and networking

beej’s guide to network programming

file system system calls

process address space

processes fork

advanced programming in unix environment…stevens

1. Never Try To Be Successful
Success is the bye-product. Excellence always creates success. So, never run after the success, let it happen automatically in the life.

2. Freedom To Life
Don’t die before actual death. Live every moment to the fullest as you are going to
die today night. Life is gifted to humankind to live, live & live @ happiness.

3. Passion Leads To Excellence
When your hobby becomes your profession and passion becomes your profession. You will be able to lead up to excellence in the life. Satisfaction, pleasure, joy and love will be the outcome of following passion. Following your passion for years, you will surely become something one day.

4. Learning Is Very Simple
Teachers do fail. Learners never fail. Learning is never complicated or difficult. Learning is always possible whatever rule you apply.

5. Pressure At Head
Current education system is developing pressures on students’ head. University intelligence is useful and making some impact in the life but it cannot be at the cost of the life.

6. Life Is Emotion Management Not Intelligence Optimization
Memory and regular study have definite value and it always helps you in leading a life. You are able to survive even if you can make some mark in the path of the life. With artificial intelligence, you can survive and win but you cannot prove yourself genius. Therefore, in this process genius dies in you.

7. Necessity Is The Mother Of Invention
Necessity creates pressure and forces you to invent something or to make it happen or to use your potentiality. Aamir Khan in this film, 3 idiots, is able to prove in the film by using aqua guard pump at the last moment.

8. Simplicity is Life
Life is need base never want base. Desires have no ends. Simplicity is way of life and Indian culture highly stresses on simple living and high thinking, and this is the way of life: ‘Legs down to earth and eyes looking beyond the sky’

9. Industrial Leadership
Dean of the institute in 3 idiots is showing very typical leadership. He has his own principles, values and ideology, and he leads the whole institute accordingly. This is an example of current institutional leadership. In the present scenario, most of the institutes are fixed in a block or Squarish thinking.

10. Love Is Time & Space Free
Love is not time bound and space bound. It is very well demonstrated in this movie same love was demonstrated by Krishna and Meera. Love is border free, time free and space free.

11. Importance Of One Word In Communication
If communication dies, everything dies. Each word has impact and value in communication. One word if used wrongly or emphasized wrongly or paused at a wrong place in communication what effect it creates and how is it affected is demonstrated very well in this movie.

12. Mediocrity Is Penalized
Middle class family or average talent or average institute is going to suffer and has to pay maximum price in the life if they do not upgrade their living standards. To be born poor or as an average person is not a crime but to die as an average person with middle class talent is miserable and if you are unable to optimize your potentiality and die with unused potentiality then that is your shameful truth. One should not die as a mediocre. He/she has to bring out genius inside him/her and has to use his/her potentiality to the optimum level.

Hmm… After 2 setbacks recently..i decide to Kick start my learning again. As part of this i started learning How to design Software. I really felt bad when i could not design an Traffic Signal software. I also wanted to Give Microsoft Certification whose fate is hanging in air. Ending no where i decided to Scrap every thing and start from the begining. I should start with Apti by RS agarwal follwed by C , C++ course work. I also need to learn Win32 and COM. Let me do one step at a time.

A Process’s Virtual Address Space

Every process is given its very own virtual address space. For 32-bit processes, this address space is 4 GB, since a 32-bit pointer can have any value from 0×00000000 through 0xFFFFFFFF. This allows a pointer to have one of 4,294,967,296 values, which covers a process’s 4-GB range. For 64-bit processes, this address space is 16 EB (exabytes), since a 64-bit pointer can have any value from 0×00000000′00000000 through 0xFFFFFFFF’FFFFFFFF. This allows a pointer to have one of 18,446,744,073,709,551,616 values, which covers a process’s 16-EB range. This is quite a range!

Since every process receives its very own private address space, when a thread in a process is running, that thread can access memory that belongs only to its process. The memory that belongs to all other processes is hidden and inaccessible to the running thread.

In Windows 2000, the memory belonging to the operating system itself is also hidden from the running thread, which means that the thread cannot accidentally access the operating system’s data. In Windows 98, the memory belonging to the operating system is not hidden from the running thread. Therefore, the running thread could accidentally access the operating system’s data and corrupt the operating system (potentially causing it to crash). It is not possible in Windows 98 for one process’s thread to access memory belonging to another process.

As I said, every process has its own private address space. Process A can have a data structure stored in its address space at address 0×12345678, while Process B can have a totally different data structure stored in its address space—at address 0×12345678. When threads running in Process A access memory at address 0×12345678, these threads are accessing Process A’s data structure. When threads running in Process B access memory at address 0×12345678, these threads are accessing Process B’s data structure. Threads running in Process A cannot access the data structure in Process B’s address space, and vice versa.

When you want something to execute every second, and your action takes 300 ms, you face the problem that with a Sleep(1000) after the action, the complete process takes more then 1300 milliseconds.

A further problem was the accuracy of a Sleep. This is not high. A Sleep of 300ms can take 310ms. a Sleep of 1ms takes at least 8ms. I did a check on different machines; it is always different and always bad.

To avoid this inaccuracy of Sleep, I only used Sleep() to approach the end time up to 15 milliseconds. In the last part, I used a dirty for() loop. Because this loop generates a big CPU usage, I only used this at the very end of the waiting time. Because of the small period, you cannot see any difference in the NT-performance meter.

When you don’t need to use this level of accuracy, only the remain sleep function, InitTimer(false), will avoid this for() loop, to the disadvantage of the accuracy.

And How Does It Work Under Water?

The best way for a good timer to operate is to use the QueryPerformanceCounter(). It gives clockpulses. Because this is hardware-dependent, we need to know the frequency (how many pulses per second). This is achieved by using QueryPerformanceFrequency(). QueryPerformanceCounter() works with a struct LARGE_INTEGER, which has some disadvantages when calculating. It’s no problem to use a LONGLONG (__int64) and cast it. This saves us from a lot of casting and time-consuming member accesses.

Because my app runs for long times, I looked to the maximum time it could run: We store in a __int64; its maximum val is 9.22337E+18 (=2^63). This is the maximum period we can sleep.