I made a change in the blogger configuration to ease the later work when blogging. It is possible that older entries are not correctly formatted.
Note the use of a certain number of configuration entries:
There are a number of other possibilities to configure Hibernate.
When starting my java application on linux, I have the following traceback:
Locking assertion failure. Backtrace:
#0 /usr/lib/libxcb-xlib.so.0 [0xc3e767]
#1 /usr/lib/libxcb-xlib.so.0(xcb_xlib_unlock+0x31) [0xc3e831]
#2 /usr/lib/libX11.so.6(_XReply+0x244) [0xc89f64]
#3 /usr/java/jre1.6.0_03/lib/i386/xawt/libmawt.so [0xb534064e]
#4 /usr/java/jre1.6.0_03/lib/i386/xawt/libmawt.so [0xb531ef97]
#5 /usr/java/jre1.6.0_03/lib/i386/xawt/libmawt.so [0xb531f248]
#6 /usr/java/jre1.6.0_03/lib/i386/xawt/libmawt.so(Java_sun_awt_X11GraphicsEnvironment_initD
It has already been discussed in a number of forums and bug reports:
http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6532373, or https://bugs.launchpad.net/ubuntu/+source/libxcb/+bug/87947
One possible work around seems to be to add the following variable setting when starting the application:
export LIBXCB_ALLOW_SLOPPY_LOCK=1
A good friend of mine gave me a NAS 1000 so that I could try a few things with it. In particular, I wanted to try PXE and diskless solutions with the installation files or disk data on the NAS server.
First I had some troubles starting the atftpd daemon because of user and group information which did not work. I should have checked the messages information right away... duh!!! It would have saved me a lot to time.
But then as I tried getting the data from my linux box using the fedora tftp client, it did not work. Well actually I am still not sure why it is not. Some routing errors obviously:
Jan 1 13:36:21 icybox daemon.info atftpd[1951]: Server thread exiting
Jan 1 13:36:26 icybox daemon.notice atftpd[1952]: Fetching from 192.168.0.104 to ess
A number of month ago, I took a look at the new features of Java 1.5 and 1.6. And I fell on the new java.util.concurrent package.
Whoever programmed GUI interfaces in Java is certainly aware of the importance of using thread to run in the background in order to enable the user to perform other tasks and not just wait in front of a screen which is not refreshing. Using nice runnable threads, you could have a much more responsive GUI. A typical example was things of the sort:
Thread t = new Thread(){
public void run(){
// the task to perform which requires a certain amount of time
}
};
SwingUtilities.invokeLater(t);
This technique is really fundamental to a well programmed graphical interface.
But since Java 1.5, there are a number of supplementary structures which can be used to perform tasks in parallel. And these are found in the package java.util.concurrent which will be the topic of a future entry.
Maven is a tool design to support as many task as possible for the management of a software project.
Its purpose is to provide a simple tool to achieve the following tasks:
A number of good tutorials can be found on maven's guide page.
Archetypes:In maven there is the possibility to create archetype models of projects. This means that it is possible to create very easily new projects which have a number of templates to start with. This is related to the possibilities of RAILS.
This is performed by issueing the following command:
$ mvn archetype:create -DgroupId=com.mycompany.app -DartifactId=my-appProject Object Model: POM
There is a concept of project object model somewhat similar to the ant build files.
An example from the website (see this page):
This model is quite easy to understand.
Project File and Directory StructureThe project file and directory structure depends on the archetype chosen to create a new project. There are means of configuring this, see: http://maven.apache.org/guides/mini/guide-creating-archetypes.html.
The build Life cycleEach possible tasks (e.g. validate, compile, package) may require other to be performed first. This means that there are dependencies between the tasks (like in ant).
Common tasksThere are a number of plugins which can be useful for maven. You can add them to the POM file of the project, see: How_do_I_use_plug-ins
A list of plugins can be found there.
SCM Plugin ( Source Code Management plugin)One of the many pluging is the SCM plugin which offers useful tasks/goals for interacting with a SCM
External DependenciesThere is also the possibility to configure external dependencies.
DeploymentThere are also possibilities of deployment if things are configured. For example, the created distribution can be copied and added to a repository using scp. For this, some information about user names, keys and/or passwords have to be configured.
DocumentationThere are also some thing to help in the creation of a documentation site using archetypes. See: guide-site.
in a few words from the wikipedia article: a CPU cache used memory management hardware to improve the speed of virtual address translation.(wikipedia).
Much information comes from this article.
The idea is that CPUs keep an associative memory to cache page table entries (PTEs) of virtual pages which were recently accessed.
When the CPU must access virtual memory, it looks up in the TLB for a number corresponding to the entry to obtain.
If an entry was found (a TLB hit), then the CPU can use the value of of the PTE which accessed and calculate the physical address.
In case it was not found (a TLB miss), then depending on the architecture, the miss is handled:
Mostly, CISC (IA-32) use hardware, while RISC (alpha) use software. IA-64 uses an hybrid approach because the hardware approach is faster but less flexible as the software one.
If the TLB is full, some entries must be replaced. For this depending on the miss handling strategy, different strategies and policy exist:
Another issue is to keep the TLB coherent with the page table it represents.
$ isoinfo -i isofilesystem.iso -J -x /filetobeextracted > filereceivingtheextracteddata
Nice!
Read Copy Update (aka RCU) is another synchronisation mechanism in order to avoid reader writer locks.
An excellent explanation can be found at the LWN.net in three parts by Paul McKenney and Jonathan Walpole:
The basic idea behind it is that when a resource is modified, a new updated structure is put in its place and the old structure is not discarded right away, it waits until references to this structure by other processes are dropped. It can be seen as similar to the concept of garbage collection, but as noted in What is RCU? Part 2: usage, the old structure is not discarded automatically when there are no references any more and the programmer must indicate the critical read portions of the code.
There is an interesting page on the RCU argueing that this technique is used more and more in the kernel as a replacement for the reader writer locks.
An important aspect of programming in an environment with threads and processes is to prevent the different processes to interfer with the functionalities of other processes at the wrong time.
In linux, a number of methods are used to ensure that the data or code section of processes is not disturbed by others. These methods are:
These locks and mechanisms are in the kernel space. Other methods or locking mechanisms are used in the user space.
The idea behind atomic operations is to perform very basic changes on variable but which cannot be interfered by other processes, because they are so small. For this, special data type is used called: atomic_t.
On this data type, a number of atomic operations can be performed:
| function | description |
|---|---|
| atomic_read(atomic_t *v) | read the variable |
| atomic_set(atomic_t *v, int i) | set the variable to i |
| atomic_add(int i, atomic_t *v) | add i to the variable |
| atomic_sub(int i, atomic_t *v) | substract i to the variable |
| atomic_sub_and_test(int i, atomic_t *v) | substract i to the variable, return true value if 0 else return false |
| atomic_inc(atomic_t *v) | increment the variable |
| atomic_inc_and_test(atomic_t *v) | increment the variable, return true value if 0 else return false |
| atomic_dec(atomic_t *v) | decrement the variable |
| atomic_dec_and_test(atomic_t *v) | decrement the variable, return true value if 0 else return false |
| atomic_add_negative(int i, atomic_t *v) | add i to the variable, and return true if its value is negative else false |
Note that I discussed in another post the local variables for CPUs.
This kind of locking is used the most, above all to protect sections for short periods from access of other processes.
The kernel checks continuously whether a lock can be taken on the data. This is an example of busy waiting.
spinlocks are used in the following way:
spinlock_t lock = SPIN_LOCK_UNLOCKED;
...
spin_lock(&lock);
/** critical operations */
spin_unlock(&lock);
Due to the busy waiting, if the lock is not released... the computer may freeze, therefore spinlocks should not be used for long times.
DECLARE_MUTEX(mutex);
....
down(&mutex);
/** critical section*/
up(&mutex);
The waiting processes then sleep in an uninterruptable state to wait for the release of the lock. The process cannot be woken up using signals during his sleep.
There are other alternatives to the down(&mutex) operation:For the user space, there are also futexes.... But this is another story.
Using this kind of locks, processors can read the locked data structure but when the structure is to be written the structure can only be manipulated by one processor at a time.
>git clone git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.git linux-2.6
2/ pulling new code from git:> git pull
3/ reverse code changes> git checkout -f
4/ commiting the modifications:> git commit -a
5/ undo last commits (note it is different from a revert which consists of a patch reverting some other patch)> git reset HEAD~2
6/ list branches> git branch
7/ create branch> git checkout -b my-new-branch-name master
8/ choose a branch and make it the current one:> git checkout branch
9/ Tell which branch is current> git status
10/ merging code into a branch mybranch> git checkout mybranch
> git merge anotherbranch