http://planet.classpath.org/ en Planet Classpath - http://planet.classpath.org/ 30 http://www.jroller.com/neugens/entry/a_day_in_the_life http://www.jroller.com/neugens/entry/a_day_in_the_life <p><center><br /> <br /> </center></p> Sun, 21 Mar 2010 22:15:56 +0000 http://www.jroller.com/neugens/entry/this_is_a_sad_news http://www.jroller.com/neugens/entry/this_is_a_sad_news <p><a href="http://www.cejug.org/2010/03/06/noticia-triste-para-o-java-no-brasil-e-o-ceara/">http://www.cejug.org/2010/03/06/noticia-triste-para-o-java-no-brasil-e-o-ceara</a></p> Fri, 19 Mar 2010 18:38:49 +0000 http://www.advogato.org/person/audriusa/diary.html?start=14 http://www.advogato.org/person/audriusa/diary.html?start=14 Today I checked SourceForge after a long gap and discovered that <a href="http://www.advogato.org/person/audriusa/rss.xml">StableUpdate</a> that I started years ago is alive, has two developers without me and gets code contribution. It is really impressive to see such things happening. Your code can live without you! Not the first time I see it yet always impressive. Fri, 19 Mar 2010 17:53:21 +0000 http://overholt.ca/wp/?p=154 http://overholt.ca/wp/?p=154 <p>The Eclipse Linux Tools team is proud to announce our 0.5.0 release. This<br /> release is compatible with the Galileo releases of the Eclipse SDK (version<br /> 3.5.x) and CDT (version 6.0.x). It is available now from our update site:</p> <p><center><br /> http://download.eclipse.org/technology/linuxtools/update<br /> </center></p> <p><a href="http://wiki.eclipse.org/Linux_Tools_Project/PluginInstallHelp">Installation instructions</a> are available. <a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&short_desc_type=allwordssubstr&short_desc=&classification=Technology&product=Linux+Tools&target_milestone=0.5&long_desc_type=allwordssubstr&long_desc=&bug_file_loc_type=allwordssubstr&bug_file_loc=&status_whiteboard_type=allwordssubstr&status_whiteboard=&keywords_type=allwords&keywords=&bug_status=RESOLVED&bug_status=VERIFIED&bug_status=CLOSED&emailtype1=substring&email1=&emailtype2=substring&email2=&bugidtype=include&bug_id=&votes=&chfieldfrom=&chfieldto=Now&chfieldvalue=&cmdtype=doit&order=Reuse+same+sort+as+last+time&field0-0-0=noop&type0-0-0=noop&value0-0-0">70 bugs</a> were closed as part of this release including bug fixes and new features. Highlights include:</p> <ul> <li>tools for the analysis and visualization of LTTng traces<br /> <a href="http://www.eclipse.org/linuxtools/new-0.5/images-0.5/lttng_perspective_thumb.png"><img src="http://overholt.ca/wp/wp-content/uploads/2010/03/lttng_perspective_thumb.png" alt="LTTng perspective" title="LTTng perspective" width="400" height="250" class="aligncenter size-full wp-image-159" /></a></li> <li>GCov integration<br /> <a href="http://www.eclipse.org/linuxtools/new-0.5/images-0.5/gcov.png"><img src="http://overholt.ca/wp/wp-content/uploads/2010/03/gcov-sm.png" alt="GCov screenshot" title="GCov screenshot" width="400" height="277" class="aligncenter size-full wp-image-166" /></a> </li> <li>a Dashboard perspective for visualising system activities<br /> <a href="http://www.eclipse.org/linuxtools/new-0.5/images-0.5/SystemTap_dashboard.png"><img src="http://overholt.ca/wp/wp-content/uploads/2010/03/SystemTap_dashboard.png" alt="SystemTap dashboard" title="SystemTap dashboard" width="400" height="276" class="aligncenter size-full wp-image-158" /></a></li> <li>many improvements to the scripts to build the Eclipse SDK for Linux distributions, now supporting Eclipse SDK version 3.5.2</li> <li>callgraphs of multi-threaded programs are now supported <a href="http://www.eclipse.org/linuxtools/new-0.5/images-0.5/threaded-screenshot.png"><img src="http://overholt.ca/wp/wp-content/uploads/2010/03/threaded-screenshot.png" alt="threaded callgraph" title="threaded callgraph" width="400" height="360" class="aligncenter size-full wp-image-156" /></a> </li> </ul> <p>The full list of highlights can be see on our <a href="http://eclipse.org/linuxtools/new">new and noteworthy page</a>. That page also contains a list of community contributions to our 0.5 release from the following excellent individuals: Niels Thykier, Benjamin Drung, and Jens Seidel. Thanks to all for their hard work and contributions. As usual, we very much appreciate feedback, be it <a href="https://bugs.eclipse.org/bugs/enter_bug.cgi?product=Linux%20Tools">bugs</a>, on IRC (Freenode #eclipse-linux), or on our <a href="https://dev.eclipse.org/mailman/listinfo/linuxtools-dev">mailing list</a>.</p> <p>Committers participating in this release include:</p> <ul> <li>William Bourque</li> <li>Francois Chouinard</li> <li>Roland Grunberg</li> <li>Anithra P Janakiraman</li> <li>Jeff Johnston</li> <li>Alexander Kurtakov</li> <li>Andrew Overholt</li> <li>Xavier Raynaud</li> <li>Alvaro Sanchez-Leon</li> <li>Charley Wang</li> </ul> <p>Thanks to everyone and looking forward to 0.6 which will be a part of the Helios release train.</p> Thu, 18 Mar 2010 20:35:49 +0000 http://blogs.sun.com/darcy/entry/covariant_interface_hierarchies http://blogs.sun.com/darcy/entry/covariant_interface_hierarchies <p> One of the changes to the Java programming language made back in JDK 5 was the introduction of <i><a href="http://en.wikipedia.org/wiki/Covariant_return_type">covariant returns</a></i>, that is, the ability in a subtype to override a method in a supertype and return a more specific type. For example, </p> <blockquote><pre> public class A { public Object method() {return null;} } public class B extends A { @Override public String method() {return "";} } </pre></blockquote> <p> Covariant returns can be a very handy facility to more accurately convey the type of object returned by a method. However, the feature should be used judiciously, especially in interface hierarchies. In interface hierarchies, covariant returns force constraints on the implementation classes. Such a constraint was included the in the <code>apt</code> API modeling the Java language and was subsequently removed from the analogous portion of the standardized JSR 269 API in <code>javax.lang.model.*</code>. </p> <p> In <code>apt</code>, the <code><a href="http://java.sun.com/javase/6/docs/jdk/api/apt/mirror/com/sun/mirror/declaration/TypeDeclaration.html">TypeDeclaration</a></code> interface defines a method<br /> <code><a href="http://java.sun.com/javase/6/docs/jdk/api/apt/mirror/com/sun/mirror/declaration/TypeDeclaration.html#getMethods()">Collection&lt;? extends MethodDeclaration&gt; getMethods()</a></code>.<br /> In the sub-interface <code><a href="http://java.sun.com/javase/6/docs/jdk/api/apt/mirror/com/sun/mirror/declaration/ClassDeclaration.html">ClassDeclaration</a></code>, the method is overriden with<br /> <code><a href="http://java.sun.com/javase/6/docs/jdk/api/apt/mirror/com/sun/mirror/declaration/ClassDeclaration.html#getMethods()">Collection&lt;MethodDeclaration&gt; getMethods()</a></code><br /> and in another sub-interface, <code><a href="http://java.sun.com/javase/6/docs/jdk/api/apt/mirror/com/sun/mirror/declaration/AnnotationTypeDeclaration.html">AnnotationTypeDeclaration</a></code>, the method is overriden with<br /> <code><a href="http://java.sun.com/javase/6/docs/jdk/api/apt/mirror/com/sun/mirror/declaration/AnnotationTypeDeclaration.html#getMethods()">Collection&lt;AnnotationTypeElementDeclaration&gt; getMethods()</a></code>.<br /> Consequently, it is not possible for a single class to implement both the <code>ClassDeclaration</code> and <code>AnnotationTypeDeclaration</code> interfaces since the language specification forbids having two methods with the same name and argument types but different return types (<a href="http://java.sun.com/docs/books/jls/third_edition/html/classes.html#8.4.2" title="Method Signature">JLSv3 &sect;8.4.2</a>). (This restriction does not exist at the class file level and a compiler will generate synthetic <i>bridge methods</i> with this property when implementing covariant returns.) If a compiler chose to use a single type to model all kinds of types (classes, enums, interfaces, annotation types), it would <em>not</em> be able to be directly retrofitted to implement the entirely of this <code>apt</code> API; wrapper objects would need to be created just to allow the interfaces to be implemented at a source level. </p> <p> In contrast, in JSR 269 the root modeling interface <code><a href="http://java.sun.com/javase/6/docs/api/javax/lang/model/element/Element.html">Element</a></code> defines a <a href="http://java.sun.com/javase/6/docs/api/javax/lang/model/element/Element.html#getEnclosedElements()">List&lt;? extends Element&gt; getEnclosedElements()</a> method which returns all kinds of enclosed elements, from fields, to constructors, to methods. Elements of a particular type can than be extracted using a <a href="http://java.sun.com/javase/6/docs/api/javax/lang/model/util/ElementFilter.html">filter</a>. This approach provides more flexibility in retrofitting the interfaces onto an existing implementation; a spectrum of implementations are possible, from a single type to represent all sorts of elements to a one-to-one correspondence of implementation types to interface types. </p> <p> Note that in cases where an implementation type collapses several interface types, <code>instanceof</code> checks for an interface type are not necessarily useful since implementing one interface does <em>not</em> imply no other related interface is implemented. The <a href="http://java.sun.com/javase/6/docs/api/javax/lang/model/element/Element.html"><code>Element</code></a> specification warns of this possibility: </p> <blockquote> To implement operations based on the class of an <code>Element</code> object, either use a visitor or use the result of the <code>getKind()</code> method. Using <code>instanceof</code> is not necessarily a reliable idiom for determining the effective class of an object in this modeling hierarchy since an implementation may choose to have a single object implement multiple <code>Element</code> subinterfaces. </blockquote> Mon, 15 Mar 2010 17:00:00 +0000 http://www.jroller.com/neugens/entry/fortune_of_the_day6 http://www.jroller.com/neugens/entry/fortune_of_the_day6 <pre>Your true value depends entirely on what you are compared with.</pre> Mon, 15 Mar 2010 12:08:46 +0000 http://www.jroller.com/neugens/entry/profiling_code http://www.jroller.com/neugens/entry/profiling_code <p>This weekend I had a chance to play a bit with the <a href="http://en.wikipedia.org/wiki/SIMD">SIMD</a> instructions of a variety of architectures (in particular the Playstation3 Cell BE and my laptop Intel Centrino vPro machine). I think I'll share the results of those tests in a different article, but for now I just want to talk about the different solutions (and especially their drawbacks) that can be used to measure the time passed while executing a critical section of code.</p> <p>While micro optimisations and micro benchmarking are usually evil for a number of reason, from time to time it's interesting to measure the performance of a chunk of code, even when the chunk is indeed small, either for comparison or to collect statistics of performance critical sections. Other times instead it's mandatory to have such measurement in order to ensure that a critical section of code runs at a constant (or at least stable) speed. One example of this that comes to my mind right now may be the main game loop of a video game.</p> <p>All of the following methods measure the time elapsed since a known "checkpoint" in time, so they all require you to grab the measure two times, one at the beginning and one at the very end of the measured section of code, and subtract the two values. The difference lies in the way this operation is performed (for example some methods use some specific structures and you need to subtracts the values of their fields), on the resolution and on the accuracy of the measurement. Not all methods are reliable in all cases for example, or the resolution may be too small to give correct results for a given problem.</p> <p><strong>Using time</strong><br /> <pre><br /> int time(time_t *calptr);<br /> </pre></p> <p>The funtion <a href="http://linux.die.net/man/2/time"><code>time</code></a> it's declared in <code>time.h</code>. This function has only one second resolution, measuring time in seconds elapsed since <a href="http://en.wikipedia.org/wiki/Unix_epoch">the Epoch</a> (oh, I wanted to write this since ever!), there are not many real use cases I think, but probably is the most portable method across the various Operating Systems.</p> <p><strong>Using gettimeofday</strong><br /> <pre><br /> int gettimeofday(struct timeval *restrict tp, void *restrict tzp);<br /> </pre></p> <p>The <a href="http://linux.die.net/man/2/gettimeofday"><code>gettimeofday</code></a> function is a BSD derived function declared in <code>sys/time.h</code>. As it sounds, you may guess that it's portable across the various Operating Systems, because it's POSIX and basically it's there in all BSD/HP/Linux/QNX/Whatever system you have, but the problem is that it's resolution is variable. In fact <code>timeval</code> contains a field that supports microsecond resolution (one millionth of a second) but whose granularity maybe not of 1 ms (and in fact it's not most of the time).</p> <p><strong>Reading directly the high resolution time register</strong></p> <p>This is the least portable way, as it relies on a specific instruction to access the high resolution time register of the target CPU. Not only, the concept of "high resolution time register" is fluff. ARM, as far as I know, doesn't have it. Recent PowerPC have a cool register called "Time Base" register and an associated assembly instruction, <code>mftb</code>. This is the case for example in the Playstation 3 Cell BE (which is probably my favourite architecture) Power Processing Unit, but if you want to profile the SPU you don't have access to this register directly. For the SPU elements you can use the SPU Decrementer and its associated instrinsics instead. This method is non portable also for older PowerPC, because they do not have the <code>mftb</code> instruction at all (and those older architecture version are very common in the embedded world). In this case you need to access two special purpose registers, <code>TBL</code> and <code>TBU</code> using the <code>mfspr</code> instruction.</p> <p>The Intel version of such register is called "Time Stamp Counter" and it's assembly is <code>rdtsc</code>. This one is available from the Pentium processor family and on, but you still have to take care to detect it on Intel compatible systems. Also on some CPU it suffers from problems when power saving is activated, it may give incorrect results when out of order execution is performed, or in general when threads are being run on multicore/multiprocessor systems.</p> <p>I'm afraid of pasting m$ related stuff, and even linking it from my blog is some sort of a sin, but <a href="http://msdn.microsoft.com/en-us/library/ee417693(VS.85).aspx">this page</a> has some details about the issues, so it's a good read after all.</p> <p>One way to fix the out of order execution problem is to call the <code>cpuid</code> instruction, because it forces every pending instruction to be executed before it is called, with the effect of actually disabling out of order execution.</p> <p>This instrinc could be used to read the Time Stamp Counter:</p> <p><pre><code><br /> static inline unsigned long long rdtsc(void)<br /> {<br /> unsigned hi, lo;<br /> __asm__ __volatile__ (<br /> "xorl %%eax, %%eax\n"<br /> "cpuid\n"<br /> "rdtsc\n"<br /> : "=a" (lo), "=d" (hi)<br /> : /* no input operands */<br /> : "%ebx", "%ecx");<br /> return (unsigned long long) hi 32 | lo;<br /> }</code><br /> </pre></p> <p>The <code>unsigned long long</code> value returned by reading the time register is usually measured in ticks elapsed since last time the CPU got resetted, so to get microsends out of ticks you need to know the frequency the clock is spinning (for example by reading <code>/proc/cpuinfo</code>).</p> <p>See what I mean for non portable?</p> <p>So, this is a good idea on some platform and a bad idea on others, although generally works fine if you do it correctly, but in my opinion it's quite a pain unless you do very specific things.</p> <p><strong>Using clock_gettime</strong><br /> <pre><br /> int clock_gettime(clockid_t clk_id, struct timespec *tp);<br /> </pre></p> <p>Last but not least the method that I think is the most accurate while maintaining a good deal of portability. <code>clock_gettime</code> is again a Posix function, but it depends on a separate library, <code>rt</code>, in order to be linked (let's say like this, it's not linked as part of the standard libc linkage like <code>gettimeofday</code> is for example). Also, gcc doesn't like it if you specify the <code>-c99</code> option, so you need to define <code>_POSIX_C_SOURCE=199309L</code> as well.</p> <p>Once this is done, the function is declared in <code>time.h</code>. The resolution is nanoseconds although the exact precision can be queried by using another function, <code>clock_getres</code>. They all take as first argument the clock id; it is in fact possible to specify a different type of clock to query, although again the number of clocks supported are system dependants.</p> <p>Most of the time we are probably interested in querying either the CPU time or the Thread time, using <code>CLOCK_PROCESS_CPUTIME_ID</code> or <code>CLOCK_THREAD_CPUTIME_ID</code>, as far as I know this function is free from most of the problems that affect the other methods.</p> <p>The <code>timespec</code> struct is similar to the <code>timeval</code> one defined for <code>gettimeofday</code>:</p> <p><pre><code><br /> struct timespec {<br /> time_t tv_sec; /* seconds */<br /> long tv_nsec; /* nanoseconds */<br /> };</code><br /> </pre></p> <p>One common operation, as said before, is to subtract between two <code>timespec</code> values before printing the result, this function may be used (I derived this from the gcc manual):</p> <p><pre><code><br /> static inline void timespecSubtract(struct timespec *result,<br /> struct timespec *start,<br /> struct timespec *stop)<br /> {<br /> if (stop->tv_nsec start->tv_nsec) {<br /> result->tv_sec = stop->tv_sec - start->tv_sec - 1;<br /> result->tv_nsec = 1000000000 + stop->tv_nsec - start->tv_nsec;<br /> } else {<br /> result->tv_nsec = stop->tv_nsec - start->tv_nsec;<br /> result->tv_sec = stop->tv_sec - start->tv_sec;<br /> }<br /> }</code><br /> </pre></p> <p>As with <code>gettimeofday</code>, we store the elapsed time in second in the <code>tv_sec</code> member, and the additional nanoseconds in the <code>tv_nsec</code> member.</p> <p><strong>Conclusion</strong></p> <p>Even a simple task as measuring elapsed time is more tricky than one could ever expect, but despite the million different ways of doing this, each with its own drawback, benefit and corner cases, it's definitely possible to still write portable code by abstracting this functionality. I hope I gave a good overview of some of the most interesting options. Also, the Internet has as always a great deal of documentation about this topic in case you want to know more on the subject.</p> <p>For example I found a good discussion about <code>clock_gettime</code> <a href="http://www.guyrutenberg.com/2007/09/22/profiling-code-using-clock_gettime/">here</a>, where the author gives a similar function in order to subtract <code>timespec</code> values. <a href="http://en.wikipedia.org/wiki/Time_Stamp_Counter">Wikipedia</a> has an interesting entry abut the Time Stamp Counter. The <a href="http://www.ibm.com/developerworks/">IBM Developer Works</a> website is as always a very great source of information, and has a good article about the <a href="http://www.ibm.com/developerworks/library/pa-timebase/">Time Base Register</a>.</p> <p>As always, <code>man</code> is your friend. The Linux man page entries for the functions presented are a great starting point (and most of the time all you need) to understand the functions under discussion. The <a href="http://docs.hp.com/en/">HP</a> and <a href="http://developer.apple.com/Mac/library/documentation/">Apple</a> developers sites are also very good, as they sometimes highlight specific issues that can help coding with portability in mind. Finally, <a href="http://stackoverflow.com/">Stackoverflow</a> is another website that is particularly helpful to find answer to common (and at times not so common) programming related questions.</p> Fri, 12 Mar 2010 20:14:27 +0000 http://blogs.sun.com/darcy/entry/last_round_compiling http://blogs.sun.com/darcy/entry/last_round_compiling <p> As of build 85 of JDK 7, bug <a href="http://bugs.sun.com/view_bug.do?bug_id=6634138">6634138 "Source generated in last round not compiled"</a> has been fixed in <code>javac</code>. Previously, source code generated in a <a href="http://java.sun.com/javase/6/docs/api/javax/annotation/processing/RoundEnvironment.html">round of annotation processing</a> where <code>RoundEnvironment.processingOver()</code> was true was not compiled. With the fix, source generated in the last round is compiled, but, as intended, while compiled such source still does not undergo annotation processing since processing is over. The fix has also been applied to OpenJDK 6 build 19. </p> Fri, 12 Mar 2010 19:53:19 +0000 http://blogs.sun.com/darcy/entry/annotation_processor_sourceversion http://blogs.sun.com/darcy/entry/annotation_processor_sourceversion <p> In annotation processing there are three distinct roles, <a href="http://blogs.sun.com/darcy/resource/J1_2005-TS-7425.pdf" title="JavaOne 2005: Annotation Processing for the Java™ Programming Language">the author of the annotation types, the author of the annotation processor, and the client of the annotations</a>. The third role includes the responsibility to configure the compiler correctly, such as <a href="http://blogs.sun.com/darcy/entry/build_advice_set_source_target" title="Build Advice: Set Source, Target, and Encoding">setting the source, target, and encoding options</a> and <a href="http://blogs.sun.com/darcy/entry/annotation_processing_build_advice_set" title="Annotation Processing Build Advice: Set source and class file destinations">setting the source and class file destination for annotation processing</a>. The author of the annotation processor shares a related responsibility: property returning <a href="http://java.sun.com/javase/6/docs/api/javax/annotation/processing/Processor.html#getSupportedSourceVersion()">the source version supported by the processor</a>. </p> <p> Most processors can be written against a particular source version and always return that source version, such as by including a <a href="http://java.sun.com/javase/6/docs/api/javax/annotation/processing/SupportedSourceVersion.html"><code>@SupportedSourceVersion</code></a> annotation on the processor class. In principle, the annotation processing infrastructure could tailor the view of newer-than-supported language constructs to be more compatible with existing processors. Conversely, processors have the flexibility to implement <a href="http://blogs.sun.com/darcy/entry/jdk_6_build_101_jsr" title="http://blogs.sun.com/darcy/entry/jdk_6_build_101_jsr">their own policies</a> when encountering objects representing newer-than-supported structures. In brief, by extending version-specific abstract visitor classes, such as <a href="http://java.sun.com/javase/6/docs/api/javax/lang/model/util/AbstractElementVisitor6.html">AbstractElementVisitor6</a> and <a href="http://java.sun.com/javase/6/docs/api/javax/lang/model/util/AbstractTypeVisitor6.html">AbstractTypeVisitor6</a>, the <code>visitUnknown</code> method will be called on entities newer than the version in question. </p> <p> Just as regression tests inside the JDK itself should by default follow a dual policy of accepting the default source and target settings rather than setting them explicitly like other programs, annotation processors used for testing with the JDK should generally support the latest source version and not be constrained to a particular version. This allows any issues or unexpected interactions of new features to be found more quickly and keeps the regression tests exercising the most recent code paths in the compiler. </p> <p> This dual policy is now consistently implemented in the <code>langtools</code> regression tests as of build 85 of JDK 7 (<a href="http://bugs.sun.com/view_bug.do?bug_id=6926699" title="Annotation processing regression tests should typically return SourceVersion.latest">6926699</a>). </p> Fri, 12 Mar 2010 18:00:00 +0000 http://gbenson.net/?p=176 http://gbenson.net/?p=176 <p>I&#8217;m back on Shark, after a four month hiatus. A minor milestone: it can <a href="http://icedtea.classpath.org/hg/icedtea6/rev/39180582f106">build itself</a> again.</p> Fri, 12 Mar 2010 09:30:12 +0000 http://blogs.sun.com/darcy/entry/assertive_quality_langtools http://blogs.sun.com/darcy/entry/assertive_quality_langtools <p> With a duo of fixes in JDK 7 build 85, one by <a href="http://blogs.sun.com/jjg/">Jon</a> (<a href="http://bugs.sun.com/view_bug.do?bug_id=6927797" title="langtools/test/tools/javac/EarlyAssert.java fails when run with assertions enabled (-ea)">6927797</a>) and another by me (<a href="http://bugs.sun.com/view_bug.do?bug_id=6926703" title="apt tests should run with assertions enabled">6926703</a>), the <code>langtools</code> repository has reached another milestone in testing robustness: all the tests pass with assertions (<code>-ea</code>) and system assertions (<code>-esa</code>) enabled. This adds to other useful <code>langtools</code> testing properties, such as being able to successufully run in the speedy <a href="http://blogs.sun.com/darcy/entry/openjdk6_build_13_regression_tests">same vm testing mode</a>. </p> <p> Jon's fix was just updating a test so that some code would always be run with assertions <em>disabled</em> while my fix corrected an actual buggy assert I included in <code>apt</code>. Addressing such problems helps simplify analyzing test results; if there is a failure, there is a problem! </p> <p> These fixes have also been applied in the forthcoming OpenJDK 6 build 19 so it too will have the same assertive testing quality. </p> Fri, 12 Mar 2010 00:40:21 +0000 http://www.jroller.com/neugens/entry/os9_s http://www.jroller.com/neugens/entry/os9_s <p>Or &#8220;things you would do to not use Windows&#8221;...</p> <p>Here is the recipe:</p> <p>1. A decent Operating System with a sane Desktop Environment (in other words Fedora 12 + Gnome because it has gvfs, which is the coolest thing in the World)<br /> 2. <span class="caps">VPN</span>/SSH access to a Linux host that has a share to all the Windows based toolchain.<br /> 3. Some scripts to automate compilation for the test files (in my case, all the usual make machinery for Jamaica).<br /> 4. A Windows shell that is used only to invoke the build machinery (and only that!).<br /> 5. Samba/NFS to share the sane Linux directories with the borked Windows machine.<br /> 6. <span class="caps">FTP</span> whatever to upload the <span class="caps">OS9</span> binaries to the target device.<br /> 7. <span class="caps">MAUI</span> and <span class="caps">OS9</span> documentation.</p> <p>Preparation (for 1 person):</p> <p>Just open a connection with nautilus to the remote Linux machine. On a separate terminal ssh into the same Linux machine and link the toolchain header files directory on a directory that is local to the mounted home (ugh, that&#8216;s a complex sentence). This is needed only if the toolchain location is not on the local machine (like in my case is mounted via nfs), the reason is that the gvfs share will only see the remote Linux machine but not all that is mounted remotely there, so the trick of linking is necessary. Create the project in NetBeans telling it that the location of the header files is the shared folder that was made visible via gvfs. Edit code as necessary. Now the tricky part. When you compile huge amount of code gvsf crashes because NetBeans polls every file that is modified and make modifies them (it set the timestamps!) so never, ever ever, never use the same virtual desktop to edit code and to issue the make command. Just go back coding when make finishes (it&#8216;s windows, so is supposed to be slow). Remember this again, don&#8216;t focus NetBeans when windows compiles code. I think this is a weird bug in gvfs, and hopefully it will be fixed. If gvfs crashes, you need to restart and reaload the project in NetBeans, which takes more time that waiting for the compilation to finish&#8230; Ah, make the customers that provide a windows only toolchain to pay twice is a good thing to do also.</p> <p>End result: Jamaica runs on <span class="caps">OS9</span> with <span class="caps">MAUI </span>:)</p> Thu, 11 Mar 2010 22:43:14 +0000 http://labb.zafena.se/?p=362 http://labb.zafena.se/?p=362 <p>When making a programming tool or a virtual machine getting the tool running perfectly stable without any crash bugs are always on a higher priority than gaining more speed. A crashing tool are a broken tool so I will share some tricks that I have practised to find and fix Shark LLVM JIT CodeGen crash bugs. The main trick are to be able generate reproducable testcases that can be reported to the LLVM developers bugzilla bugtracker by using what you can extract from the Shark LLVM JIT CodeGen crashes. Here is how I do it, enjoy!</p> <p><b> How to provoke hard to find Shark LLVM JIT bugs </b><br /> Some Shark LLVM JIT bugs are hard to find because they only occour after the Shark JIT enabled JVM have been running for a long time, this are because the Shark Hotspot JVM takes advantage of the fact that a given running application spends about 90% of its time running only 10% of the applications code. Hotspot profiles the running code and only JITs the most frequently used methods of the program. Hotspot uses a threshold to determine which methods to JIT. When a method have been used more than 100000 times then it are scheduled to be optimized by the JIT. JIT bugs can stay undetected if they are located in unfrequently executed methods, those methods that makes up the 90%, of the unfrequently executed application code.</p> <p>A easy trick to provoke unfrequently executed JIT bugs are to lower the JIT threshold in Hotspot so that Hotspot JITs everything. The JIT threshold can be controlled by using the -XX:CompileThreshold=1 option and -Xbatch option. -Xbatch prevents the hotspot from running the JIT in background and will make hotspot reproduce JIT bugs more determistic. </p> <p>Using a low JIT threshold will of course make the program startup magnitudes slower but it will also eventually find and hit all JIT bugs for a given application. Try pass -XX:+PrintCompilation to Hotspot as well so that you can observe all the java methods that Hotspot are JITting and find out which method that failed to JIT if Hotspot hits a JIT crash bug.<br /> <code>java -XX:CompileThreshold=1 -Xbatch -XX:+PrintCompilation JavaApplication<br /> 1 b java.lang.Thread:: (49 bytes)<br /> &#8230;<br /> 10 b java.lang.String::getChars (66 bytes)<br /> *crash*<br /> /home/xerxes/llvm/include/llvm/CodeGen/MachineFrameInfo.h:289: int64_t<br /> llvm::MachineFrameInfo::getObjectOffset(int) const: Assertion<br /> `!isDeadObjectIndex(ObjectIdx) &#038;&#038; &#8220;Getting frame offset for a dead object?&#8221;&#8216;<br /> failed.</code></p> <p>Huh.. no logfile??<br /> Most Shark LLVM JIT CodeGen crash bugs makes the JVM instantainiously exit without producting a hs_err_pid*.log file. Whats usefull are that the JVM output will contain a Assertion, Unreachable or Unimplemented keyword and a LLVM code line numer.</p> <p>So what do we do now?<br /> Thanks by using -XX:+PrintCompilation makes us aware that the last method JITed was the java.lang.String::getChars method and that caused the Assertion in the LLVM CodeGen when running the Shark JIT so the next step are to dump the LLVM IR that Shark have generated for the method.<br /> <br /> <b> Extract the LLVM IR for the java method that makes the Shark JIT crash.</b><br /> Ok so we got a crash and we know that it was JITing of java.lang.String::getChars that caused it.</p> <p><b>a)</b> shark debug build -XX:SharkPrintBitcodeOf= method:<br /> If you have built a <a href="http://gbenson.net/?p=100">debuggable &#8220;Mixtech&#8221; Shark build</a> then Shark will contain some extra usefull debug runtimeoptions where one of the more usefull are<br /> -XX:SharkPrintBitcodeOf=java.package.name::MethodName<br /> use it and Shark will dump the LLVM IR bitcode to stdout just before jitting it.</p> <p><b>b)</b> gdb call F->dump() method:<br /> I personally prefer dumping LLVM IR from inside the gnu gdb debugger since this method can be used using release Shark build in combination with release llvm builds so lets jump into the gdb debugger!</p> <p>Start gdb and attach it to the java application with all the options that triggered the JIT CodeGen bug!<br /> <code>$ gdb -args java -XX:CompileThreshold=1 -Xbatch -XX:+PrintCompilation JavaApplication<br /> (gdb) run<br /> ...<br /> Segmentation fault<br /> $ </code></p> <p>Ick gdb crashed why? This are because the JVM launcher &#8220;java&#8221; first sets up the system environment and then forks off in a new process using execve(). gdb gets killed by the linux kernel when it are trying to read memory across process boundarys so we must stop java from forking!</p> <p>The easiest way to prevent java from forking are to setup the system environments before launching the application. And all this can be done from inside gdb so lets try again!<br /> <code>$ gdb -args java -XX:CompileThreshold=1 -Xbatch -XX:+PrintCompilation JavaApplication<br /> (gdb) break execve<br /> Breakpoint 1 at 0x93b8<br /> (gdb) run<br /> (gdb) call puts(getenv("LD_LIBRARY_PATH"))<br /> /media/disk/4mar-shark-1.8pre-b18-llvm-2.7svn.so-npplugin/jre/lib/arm/server:/media/disk/4mar-shark-1.8pre-b18-llvm-2.7svn.so-npplugin/jre/lib/arm:/media/disk/4mar-shark-1.8pre-b18-llvm-2.7svn.so-npplugin/jre/../lib/arm<br /> $1 = 220</code></p> <p>Ok now we know what the LD_LIBRARY_PATH should look like and if we set it before running the java launcher will prevent java from forking using execve, this <a href="http://blogs.sun.com/darcy/entry/purging_ld_library_path">LD_LIBRARY_PATH and execve madness are thankfully gone in JDK7</a>!<br /> <code>(gdb) set env LD_LIBRARY_PATH=/media/disk/4mar-shark-1.8pre-b18-llvm-2.7svn.so-npplugin/jre/lib/arm/server:/media/disk/4mar-shark-1.8pre-b18-llvm-2.7svn.so-npplugin/jre/lib/arm:/media/disk/4mar-shark-1.8pre-b18-llvm-2.7svn.so-npplugin/jre/../lib/arm</code><br /> I will do one more thing namely set a gdb breakpoint inside java_md.c:652 right after the hotspot library libjvm.so have been loaded by the java launcher.<br /> <code>(gdb) break java_md.c:652<br /> (gdb) run<br /> The program being debugged has been started already.<br /> Start it from the beginning? (y or n) y<br /> ...<br /> Breakpoint 2, LoadJavaVM ... java_md.c:652<br /> 652 if (libjvm == NULL) {</code></p> <p>This are a good spot to setup new gdb breakpoints inside the loaded libjvm.so that contains the Shark JIT. Finally we are able to place a breakpoint on the line where the Shark JIT failed inside LLVM.<br /> <code>(gdb) break MachineFrameInfo.h:289<br /> (gdb) continue<br /> Continuing.<br /> ...<br /> 10 b java.lang.String::getChars (66 bytes)<br /> [Switching to Thread 0x67ed96a490 (LWP 21127)]</code></p> <p>Breakpoint 3, &#8230; at &#8230; MachineFrameInfo.h:289</p> <p>Get a backtrace and try to locate the frame where Shark calls getPointerToFunction<br /> <code>(gdb) bt<br /> ...<br /> #9 0x40d4ee68 in llvm::JIT::getPointerToFunction (this=0x9e138, F=0xda6f0)<br /> ...</code></p> <p>Switch to the getPointerToFunction stack frame<br /> <code>(gdb) frame 9</code><br /> and finnaly dump the LLVM IR for the function by calling the functions own method dump() !<br /> <code>(gdb) call F->dump()<br /> define internal void @"java.lang.String::getChars"([84 x i8]* %method, i32 %base_pc, [788 x i8]* %thread) {<br /> %1 = getelementptr inbounds [788 x i8]* %thread, i32 0, i32 756 ; [#uses=1]<br /> %zero_stack = bitcast i8* %1 to [12 x i8]* ; [12 x i8]*> [#uses=1]<br /> %2 = getelementptr inbounds [12 x i8]* %zero_stack, i32 0, i32 8 ; [#uses=1]<br /> %stack_pointer_addr = bitcast i8* %2 to i32* ; [#uses=1]<br /> %3 = load i32* %stack_pointer_addr ; [#uses=1]<br /> &#8230;<br /> %142 = getelementptr inbounds [17 x i32]* %frame, i32 0, i32 12 ; [#uses=1]<br /> store i32 %31, i32* %142<br /> call void inttoptr (i32 13839116 to void ([788 x i8]*, i32)*)([788 x i8]* %thread, i32 7)<br /> ret void<br /> }</code></p> <p>Horray! we have successfully dumped the Shark generated LLVM IR for the problematic method-call. Now simply copy the dump output from the terminal into a file named bug.ll and continue reading.</p> <p> <b> Check for LLVM CodeGen bugs by testing if the dumped LLVM IR bug.ll file can reproduce the bug using llc</b><br /> After you have extracted LLVM IR for the problematic method check if you can reproduce the bug using llc..<br /> <code>$ llvm-as &lt; bug.ll | llc<br /> .syntax unified<br /> .eabi_attribute 20, 1<br /> .eabi_attribute 21, 1<br /> .eabi_attribute 23, 3<br /> .eabi_attribute 24, 1<br /> .eabi_attribute 25, 1<br /> .file "&#8221;<br /> llc:<br /> /wd/buildbot/llvm-arm-linux/llvm/include/llvm/CodeGen/MachineFrameInfo.h:289:<br /> int64_t llvm::MachineFrameInfo::getObjectOffset(int) const: Assertion<br /> `!isDeadObjectIndex(ObjectIdx) &#038;&#038; &#8220;Getting frame offset for a dead object?&#8221;&#8216;<br /> failed.<br /> 0 llc 0&#215;01368414<br /> 1 llc 0&#215;01368ccc<br /> 2 libc.so.6 0&#215;4021cc10 __default_sa_restorer_v2 + 0<br /> Stack dump:<br /> 0. Program arguments: /wd/r96575/Debug/bin/llc -march=arm<br /> 1. Running pass &#8216;Prolog/Epilog Insertion &#038; Frame Finalization&#8217; on function<br /> &#8216;@&#8221;java.lang.String::getChars&#8221;&#8216;<br /> Aborted</code></p> <p>If it crashes using llc then cheer up because you now got a reproducable CodeGen bug and thats great! These kind of crash bugs are on LLVM developers top wanted list because they can fire on any tool that uses LLVM code generation. The best way to report this kind of bugs are to first generate a compact testcase for LLVM that triggers the bug that can be used by the LLVM developers to fix it. It can also be run by the LLVM developers daily regression testing to make sure this bug never hits again.</p> <p>If it fails to crash with an Aborted like above then you are probably observing a JIT CodeEmitter runtime bug, stay tuned and look forward to my next blog post on &#8220;How to fix Shark LLVM JIT CodeEmitter bugs&#8221;!<br /> <br /><b>How to generate a <b>bugpoint-reduced-simplified.bc</b> from the bug.ll using <b>bugpoint</b> for CodeGen crash bugs</b><br /> LLVM ships with a clever tool called <a href="http://llvm.org/docs/Bugpoint.html">bugpoint</a> that are designed to convert dumped blocks of LLVM IR into a compact bugpoint-reduced-simplified.bc LLVM bitcode testcase file that only contains the instructions needed to reproduce the bug.</p> <p><code>$ bugpoint -run-llc bug.ll --tool-args -march=arm</code></p> <p>Bugpoint work by using deductive logic to break down and remove parts of the bug.ll file and automatically narrow down the LLVM IR lines needed to reproduce the bug. It can take some minutes so be patient but bugpoint will eventually stop and give you a bugpoint-reduced-simplified.bc and print some information on how to reproduce the bug.</p> <p> <b>File a LLVM bugreport containing the bugpoint-reduced-simplified.bc file</b><br /> An example of a Shark JIT LLVM bug that have been fixed after submitting a bugpoint-reduced-simplified.bc produced from a dumped Shark metod are :<br /> <a href="http://llvm.org/bugs/show_bug.cgi?id=6478">LLVM PR6478 ARM CodeGen Running pass &#8216;Prolog/Epilog Insertion &#038; Frame Finalization&#8217; on function &#8216;@&#8221;java.lang.String::getChars&#8221;&#8216; </a><br /> <br /> I hope this post have given you some inspiration on how to get Shark LLVM JIT CodeGen crash bugs fixed!<br /> If you want to know more about how bugpoint works and how to officially prepare LLVM bugreports then take a peek at the LLVM documentation: <a href="http://llvm.org/docs/HowToSubmitABug.html">http://llvm.org/docs/HowToSubmitABug.html</a> its great.</p> <p>Xerxes</p> Wed, 10 Mar 2010 16:57:10 +0000 http://labb.zafena.se/?p=337 http://labb.zafena.se/?p=337 <p><a href="http://labb.zafena.se/wp-content/uploads/2010/03/sharkjitautocpufeaturesopt.png"><img class="alignright size-full wp-image-338" title="Shark LLVM JIT on ARM Cortex-A8 using automatic CPU features tuning passes CaffeineMark 3.0 2000 points score mark." src="http://labb.zafena.se/wp-content/uploads/2010/03/sharkjitautocpufeaturesopt.png" alt="" width="435" height="299" /></a><br /> I have from time to time been working on a automatic CPU feature tuning code for Shark to make the LLVM JIT generate better code for Cortex-A8 class ARM CPUs. Using it i was able to gain some substantial speed-improvements, all in all it made Shark generate 30% faster code on ARM and the Shark JIT are now able to beat the 2000 point CaffeineMark 3.0 score! I could not resist using CaffeineMark 3.0 for some benchmarking again <img src="http://labb.zafena.se/wp-includes/images/smilies/icon_smile.gif" alt=":)" class="wp-smiley" /> .</p> <p>While this looks all great with rainbows and unicorns the patch are sadly in limbo. I have had some trouble merging the code into LLVM 2.7 trunk before the next LLVM release since I got hit by <a href="http://www.llvm.org/bugs/show_bug.cgi?id=6544">LLVM problem report 6544</a> that will force me to redesign the implementation on top of LLVM before it can be commited.</p> <p>And a similar optimisation like what i did for ARM Linux can easily be done for Shark on PPC Linux as well by adopting the ARM CPU features detection code from ARM to PPC!<br /> For those who are interested the optimising code are submitted and can be fetched from <a href="http://www.llvm.org/bugs/show_bug.cgi?id=5389">LLVM PR5389</a>.</p> <p>Cheers and have a great day!<br /> Xerxes</p> Tue, 09 Mar 2010 15:28:11 +0000 http://www.jroller.com/neugens/entry/nested_functions5 http://www.jroller.com/neugens/entry/nested_functions5 Funny thing in C that I discovered today and thought I would share. I found out that is not only possible to declare a function in the scope of another one, but also to define it, at least with GCC (I think this is a language extension, not sure if some "later" standard like c99 officially supports it). Of course, this uber cool feature just makes code more funny, but it may have it's own uses (other than writing obfuscated code, I mean :) Here is some code: <pre> int main(void) { void testMe(void) { fprintf(stderr, "b0rk3d!\n"); } testMe(); return (EXIT_SUCCESS); } </pre> without optimisations, gcc creates a regular function call, with optimisation I guess it depends on how often you use it, but this simple test gets (unsurprisingly, I guess) inlined. Very cool :) Fri, 05 Mar 2010 16:04:11 +0000 http://rkennke.wordpress.com/?p=309 http://rkennke.wordpress.com/2010/03/04/beatles-review-a-hard-days-night/ <p>Now we come to the first peak in The Beatles&#8217; career: their 3rd album <a href="http://www.lastfm.de/music/The+Beatles/A+Hard+Day%27s+Night">A Hard Day&#8217;s Night</a>. Somewhere I&#8217;ve read that this album sounds like somebody opened a bottle of champaign, and this hits the nail on its head. Where the last album <a href="http://rkennke.wordpress.com/2010/02/24/beatles-review-with-the-beatles/">With The Beatles</a> was slightly dark, this here is all bright, hyperactive and full of adrenaline. It starts with the weird opening chord (which <a href="http://www.scientificblogging.com/news_releases/beatles_unknown_hard_days_night_chord_mystery_solved_using_fourier_transform">puzzled even scientists</a> because nobody was able to find out exactly what chord it was until 2008) of the title song, and runs through a set of 13 Beatles originals (yeah right, no cover versions this time). It shows all the good qualities of the early Beatles, their incredible vocal harmonies, their simple-yet-intriguing melodies and rhythms. And it shows the incredible fun and energy that the guys had.</p> <p>I remember a fun little story. When I was young (much younger than now at least), I saved myself a lot of money (around 30 DM, approx. 15€ nowadays) to buy this album on CD. That must have been in 1992 or so, I was about 14. I didn&#8217;t even have a CD player! So I went to the closest supermarket, gave away my hard-earned money to get this CD. And when I was home and saw &#8216;Mono&#8217; on the package, I was so disappointed, because I believed that this was a fake thing. In my childish view I assumed that the real thing must be stereo because stereo is obviously better, no? In the end, I went back to the supermarket and returned the CD (that was quite a funny and geeky argument with the salesguy, not wanting the CD because it&#8217;s mono). But not without first going to a friend and making a copy of it to cassette tape. Yay <img src="http://s.wordpress.com/wp-includes/images/smilies/icon_biggrin.gif" alt=":-D" class="wp-smiley" /> Only much later I realized that the mono version was indeed the official version and bought the CD again. Now I have both, and comparing the versions I must say that the mono version is indeed better, again there are a bunch of glitches on stereo (the start of &#8216;Should Have Known Better&#8217; for example) that have been corrected in mono. It needs to be said that at this time mono was by far the dominant format and the Beatles themselves never really cared for the stereo mixes, leaving them to others, while attending the mono mixes themselves. However, compared to the first two albums, which have this funny extreme left-right panning, the stereo mixes are a bit more sane, which owes to the fact that they used 4 track recording for the first time.</p> <p>That was a bit technical this time, I usually try to avoid that because we want to listen to music, not technology, right? I enjoyed listening to this album today anyway. Quite alot even. Next time I will have a look (listen) at the Beatles for Sale.</p> <br /> <a rel="nofollow" href="http://feeds.wordpress.com/1.0/gocomments/rkennke.wordpress.com/309/"><img alt="" border="0" src="http://feeds.wordpress.com/1.0/comments/rkennke.wordpress.com/309/" /></a> <a rel="nofollow" href="http://feeds.wordpress.com/1.0/godelicious/rkennke.wordpress.com/309/"><img alt="" border="0" src="http://feeds.wordpress.com/1.0/delicious/rkennke.wordpress.com/309/" /></a> <a rel="nofollow" href="http://feeds.wordpress.com/1.0/gostumble/rkennke.wordpress.com/309/"><img alt="" border="0" src="http://feeds.wordpress.com/1.0/stumble/rkennke.wordpress.com/309/" /></a> <a rel="nofollow" href="http://feeds.wordpress.com/1.0/godigg/rkennke.wordpress.com/309/"><img alt="" border="0" src="http://feeds.wordpress.com/1.0/digg/rkennke.wordpress.com/309/" /></a> <a rel="nofollow" href="http://feeds.wordpress.com/1.0/goreddit/rkennke.wordpress.com/309/"><img alt="" border="0" src="http://feeds.wordpress.com/1.0/reddit/rkennke.wordpress.com/309/" /></a> <img alt="" border="0" src="http://stats.wordpress.com/b.gif?host=rkennke.wordpress.com&blog=9951657&post=309&subd=rkennke&ref=&feed=1" />rkennke Thu, 04 Mar 2010 23:18:25 +0000 http://blog.fuseyism.com/?p=95 http://blog.fuseyism.com/index.php/2010/02/26/icedtea6-171-released/ <p>We are pleased to announce the release of IcedTea6 1.7.1!</p> <p>The IcedTea project provides a harness to build the source code from<br /> OpenJDK6 using Free Software build tools. It also includes the only<br /> Free Java plugin and Web Start implementation, and support for<br /> additional architectures over and above x86, x86_64 and SPARC via the<br /> Zero assembler port.</p> <h2>What&#8217;s New?</h2> <h3>Bug fixes</h3> <ul> <li><a href="http://icedtea.classpath.org/bugzilla/show_bug.cgi?id=179">PR179</a>: Rhino bootclasspath issue</li> <li>Add missing .c file to PulseAudio build</li> <li>Zero/Shark <ul> <li>Formatting changes and other fixes to match upstream</li> <li><a href="http://icedtea.classpath.org/bugzilla/show_bug.cgi?id=428">PR428</a>: Shark on ARM precompiled header incls</li> <li>Update Shark for LLVM r95390 API change.</li> <li><a href="http://bugs.sun.com/view_bug.do?bug_id=6927165">S6927165</a>: Zero S/390 fixes (from upstream)</li> <li>Implemented Shark host CPU feature autotuner using LLVM 2.7 APIs.</li> <li>Add s390 support to TCK setup helper script</li> <li>Strip stupid options that llvm-config supplies</li> <li>Update Shark for LLVM r94686 API change.</li> <li><a href="http://bugs.sun.com/view_bug.do?bug_id=6914622">S6914622</a>, <a href="http://bugs.sun.com/view_bug.do?bug_id=6909153">S6909153</a>, <a href="http://bugs.sun.com/view_bug.do?bug_id=6913869">S6913869</a> upstream Zero fixes.</li> </ul> </li> <li>NPPlugin fixes <ul> <li><a href="http://icedtea.classpath.org/bugzilla/show_bug.cgi?id=446">PR446</a>: Use JDK_UPDATE_VERSION to set the jpi version.</li> <li>Re-designed frame embedding code so that the applet is dynamically packed into given handle. This increases stability and breaks reliance on the assumption that the browser will always provide a handle in a certain sequence.</li> <li>Encode new lines, carriage returns, and other special characters before sending them to Java side (de-coding code is already in effect on the Java side).</li> <li>Centralised and increased timeouts to give slow-loading applets enough time to load.</li> <li>Fix security permissions related to get/set property, based on specifications.</li> </ul> </li> </ul> <p>The tarball can be downloaded from:</p> <ul> <li><a href="http://icedtea.classpath.org/download/source/icedtea6-1.7.1.tar.gz">http://icedtea.classpath.org/download/source/icedtea6-1.7.1.tar.gz</a></li> </ul> <p>The following people helped with the 1.7 release series:</p> <p>Lillian Angel, Gary Benson, Deepak Bhole, Andrew Haley, Andrew John Hughes, Nobuhiro Iwamatsu, Matthias Klose, Martin Matejovic, Edward Nevill, Xerxes Rånby, Robert Schuster,Jon VanAlten, Mark Wielaard and Man Lung Wong.</p> <p>We would also like to thank the bug reporters and testers!</p> <p>To get started:</p> <pre> $ tar xzf icedtea6-1.7.1.tar.gz $ cd icedtea6-1.7.1 </pre> <p>Full build requirements and instructions are in INSTALL:</p> <pre> $ ./configure [--enable-visualvm --with-openjdk --enable-pulse-java --enable-systemtap ...] $ make </pre> Fri, 26 Feb 2010 17:52:18 +0000 http://blogs.sun.com/darcy/entry/notions_of_floating_point_equality http://blogs.sun.com/darcy/entry/notions_of_floating_point_equality <p> Moving on from <a href="http://blogs.sun.com/darcy/entry/api_design_identity_and_equality" title="API Design: Identity and Equality">identity and equality of objects</a>, different notions of equality are also surprisingly subtle in some numerical realms. </p> <p> As <a href="http://mail.openjdk.java.net/pipermail/nio-dev/2009-November/000792.html" title="Nov. 2009 nio-dev thread on DoubleBuffer.compareTo is not anti-symmetric">comes up from time to time</a> and is often surprising, the "<code>==</code>" operator defined by IEEE 754 and used by Java for comparing floating-point values (<a href="http://java.sun.com/docs/books/jls/third_edition/html/expressions.html#15.21.1" title="Numerical Equality Operators == and !=">JLSv3 &sect;15.21.1</a>) is <em>not</em> an <i><a href="http://en.wikipedia.org/wiki/Equivalence_relation">equivalence relation</a></i>. Equivalence relations satisfy three properties, reflexivity (something is equivalent to itself), symmetry (if <i>a</i> is equivalent to <i>b</i>, <i>b</i> is equivalent to <i>a</i>), and transitivity (if <i>a</i> is equivalent to <i>b</i> and <i>b</i> is equivalent to <i>c</i>, then <i>a</i> is equivalent to <i>c</i>). </p> <p> The IEEE 754 standard defines four possible mutually exclusive ordering relations between floating-point values:</p> <ul> <li><p>equal </p> <li><p>greater than </p> <li><p>less than </p> <li><p>unordered </p> </li></li></li></li></ul> <p> A NaN (Not a Number) is <em>unordered</em> with respective to every floating-point value, including itself. This was done so that NaNs would not quietly slip by without due notice. Since (NaN == NaN) is false, the IEEE 754 "<code>==</code>" relation is <em>not</em> an equivalence relation since it is not reflexive. </p> <p> An equivalence relation partitions a set into equivalence classes; each member of an equivalence classes is "the same" as the other members of the classes for the purposes of that equivalence relation. In terms of numerics, one would expect equivalent values to result in equivalent numerical results in all cases. Therefore, the size of the equivalence classes over floating-point values would be expected to be one; a number would only be equivalent to itself. However, in IEEE 754 there are two zeros, -0.0 and +0.0, and they compare as equal under <code>==</code>. For IEEE 754 addition and subtraction, the sign of a zero argument can at most affect the sign of a zero result. That is, if the sum or difference is not zero, a zero of either sign doesn't change the result. If the sum or differnece is zero and one of the arguments is zero, the other argument must be zero too: </p> <ul> <li><p>-0.0 + -0.0 &rArr; -0.0 </p> <li><p>-0.0 + +0.0 &rArr; +0.0 </p> <li><p>+0.0 + -0.0 &rArr; +0.0 </p> <li><p>+0.0 + +0.0 &rArr; +0.0 </p> </li></li></li></li></ul> <p> Therefore, under addition and subtraction, both signed zeros are equivalent. However, they are <em>not</em> equivalent under division since 1.0/<b>-</b>0.0 &rArr; -&#8734; but 1.0/<b>+</b>0.0 &rArr; +&#8734; and -&#8734; and +&#8734; are <em>not</em> equivalent.<a href="http://blogs.sun.com/darcy/feed/entries/rss#affine">¹</a> </p> <p> Despite the rationales for the IEEE 754 specification to not define <code>==</code> as an equivalence relation, there are legitimate cases where one needs a true equivalence relation over floating-point values, such as when writing test programs, and cases where one needs a total ordering, such as when sorting. In my numerical tests I use a method that returns <code>true</code> for two floating-point values <i>x</i> and <i>y</i> if:<br /> ((<i>x</i> == <i>y</i>) &amp;&amp;<br /> (if <i>x</i> and <i>y</i> are both zero they have the same sign)) || <br /> (x and y are both NaN)<br /> Conveniently, this is just computed by using <code>(Double.compare(x, y) == 0)</code>. For sorting or a total order, the semantics of <a href="http://java.sun.com/javase/6/docs/api/java/lang/Double.html#compare(double,%20double)"><code>Double.compare</code></a> are fine; NaN is treated as being the largest floating-point values, greater than positive infinity, and -0.0 +0.0. That ordering is the total order used by by <a href="http://java.sun.com/javase/6/docs/api/java/util/Arrays.html#sort(double[])"><code>java.util.Arrays.sort(double[])</code></a>. In terms of semantics, it doesn't really matter where the NaNs are ordered with respect to ther values to as long as they are consistently ordered that way.^{<a href="http://blogs.sun.com/darcy/feed/entries/rss#bitwise">2</a>} </p> <p> These subtleties of floating-point comparison were also germane on the Project Coin mailing list last year; the <a href="http://mail.openjdk.java.net/pipermail/coin-dev/2009-March/000566.html">definition of floating-point equality was discussed in relation to adding support for relational operations based on a type implementing the <code>Comparable</code> interface</a>. That thread also broached the complexities involved in comparing <a href="http://java.sun.com/javase/6/docs/api/java/math/BigDecimal.html">BigDecimal</a></p> values. <p> The <code>BigDecimal</code> class has a natural ordering that is <em>inconsistent with equals</em>; that is for at least some inputs <code>bd1</code> and <code>bd2</code>, <br /> <code>c.compare(bd1, bd2)==0</code><br /> has a different boolean value than<br /> <code>bd1.equals(bd2)</code>.^{<a href="http://blogs.sun.com/darcy/feed/entries/rss#consistent">3</a>}<br /> In <code>BigDecimal</code>, the same numerical value can have multiple representations, such as (100 &times; 10⁰) versus (10 &times; 10¹) versus (1 &times; 10²). These are all "the same" numerically (<code>compareTo == 0</code>) but are <em>not</em> <code>equals</code> with each other. Such values are not equivalent under the operations supported by <code>BigDecimal</code>; for example (100 &times; 10⁰) has a <i><a href="http://java.sun.com/javase/6/docs/api/java/math/BigDecimal.html#scale()">scale</a></i> of 0 while (1 &times; 10²) has a scale of -2.^{<a href="http://blogs.sun.com/darcy/feed/entries/rss#cohort">4</a>} </p> <p> While subtle, the different notions of numerical equality each serve a useful purpose and knowing which notion is appropriate for a given task is an important factor in writing correct programs. </p> <hr width="50%" /> <blockquote> <p> <a name="affine">¹</a> There are two zeros in IEEE 754 because there are two infinities. Another way to extend the real numbers to include infinity is to have a single (unsigned) projective infinity. In such a system, there is only one conceptual zero. Early x87 chips before IEEE 754 was standardized had support for both signed (affine) and projective infinities. Each style of infinity is more convenient for some kinds of computations. </p> <p> ^{<a name="bitwise">2</a>} Besides the equivalence relation offered by <code>Double.compare(x, y)</code>, another equivalence relation can be induced by either of the bitwise conversion routines, <a href="http://java.sun.com/javase/6/docs/api/java/lang/Double.html#doubleToLongBits(double)">Double.doubleToLongBits</a> or <a href="http://java.sun.com/javase/6/docs/api/java/lang/Double.html#doubleToRawLongBits(double)">Double.doubleToRawLongBits</a>. The former collapses all bit patterns that encode a NaN value into a single canonical NaN bit pattern, while the latter can let through a platform-specific NaN value. Implementation freedoms allowed by the original IEEE 754 standard have allowed different processor families to define different conventions for NaN bit patterns. </p> <p> ^{<a name="consistent">3</a>} I've at times considered whether it would be worthwhile to include an "<code>@NaturalOrderingInconsistentWithEquals</code>" annotation in the platform to flag the classes that have this quirk. Such an annotation could be used by various checkers to find potentially problematic uses of such classes in sets and maps. </p> <p> ^{<a name="cohort">4</a>} Building on wording developed for the <code>BigDecimal</code> specification under <a href="http://jcp.org/en/jsr/detail?id=13">JSR 13</a>, when I was editor of the <a href="http://en.wikipedia.org/wiki/IEEE_754-2008">IEEE 754 revision</a>, I introduced several pieces of decimal-related terminology into the draft. Those terms include <i>preferred exponent</i>, analogous to the preferred scale from <code>BigDecimal</code>, and <i>cohort</i>, "The set of all floating-point representations that represent a given floating-point number in a given floating-point format." Put in terms of <code>BigDecimal</code>, the members of a cohort would be all the <code>BigDecimal</code> numbers with the same numerical value, but distinct pairs of scale (negation of the exponent) and unscaled value. </p> </blockquote> Fri, 26 Feb 2010 09:00:00 +0000 http://labb.zafena.se/?p=316 http://labb.zafena.se/?p=316 <p>During the past months i have seen some really cool stuff done using small powerefficient ARM computers and OpenJDK.</p> <div id="attachment_318" class="wp-caption alignright" style="width: 235px"><a href="http://labb.zafena.se/wp-content/uploads/2010/02/simplesimon-connects.jpg"><img class="size-medium wp-image-318" title="simplesimon-connects" src="http://labb.zafena.se/wp-content/uploads/2010/02/simplesimon-connects.jpg" alt="SimpleSimon connects" width="225" height="300" /></a><p class="wp-caption-text">Simple Simon PT connected to a hospital laboratory system by using a powerefficient plugcomputer and displaylink usb screen. All powered by OpenJDK</p></div> <p><strong>Simple Simon PT connects:</strong></p> <p>This project hooks up a battery powered laboratory coagulation device, a Simple Simon PT reader to standard hospital laboratory system using a ASTM-1394-1397 / LIS2-A2 connectivity over ethernet. A small ARM based plugcomputer does all data message processing and communication. User interraction are performed by using the Simon reader and a usb-barcode reader to enter laboratory identification. Optionally can a usb-touch-screen be connected for improved user feedback, by displaying charts using JFreeChart, to show and give a better understanding of the coagulation process.</p> <p>Powerconsumption tops at 15W with the USB screen attached and 6W without. All running silent without any moving parts!</p> <div id="attachment_317" class="wp-caption alignnone" style="width: 310px"><a href="http://labb.zafena.se/wp-content/uploads/2010/02/shark-linked-against-shared-libllvm27svso.jpg"><img class="size-medium wp-image-317" title="shark-linked-against-shared-libllvm27svso" src="http://labb.zafena.se/wp-content/uploads/2010/02/shark-linked-against-shared-libllvm27svso.jpg" alt="Shark linked against the shared libLLVM-2.7svn.so" width="300" height="225" /></a><p class="wp-caption-text">Shark linked against the shared libLLVM-2.7svn.so</p></div> <p><strong>Shark linked against dynamic LLVM .so library</strong></p> <p>Earlier today I got Shark linked against a shared libLLVM-2.7svn.so generated by using LLVM 2.7svn trunk. It work by simply building LLVM using configure &#8211;enable-shared &#8211;enable-optimized &#8211;disable-assertions and then tweak the Icedtea6 main Makefiles to use the shared library during liking:<br /> Replace the line<br /> <code>LLVM_LIBS = -lLLVMX86Disassembler -lLLVMX86AsmParser -lLLVMMCParser -lLLVMX86AsmPrinter -lLLVMX86CodeGen -lLLVMSelectionDAG -lLLVMAsmPrinter -lLLVMX86Info -lLLVMJIT -lLLVMExecutionEngine -lLLVMCodeGen -lLLVMScalarOpts -lLLVMInstCombine -lLLVMTransformUtils -lLLVMipa -lLLVMAnalysis -lLLVMTarget -lLLVMMC -lLLVMCore -lLLVMSupport -lLLVMSystem</code><br /> with<br /> <code>LLVM_LIBS = -lLLVM-2.7svn</code><br /> in the main icedtea6/Makefile and then build Icedtea6 normally, Shark currently builds and works right out of the box when using a LLVM release build!</p> <p>A cool thing by building shark against the shared library are that you can switch the LLVM JIT that Shark uses from running with or without assertions, debug code, and various extra optimizations by simply replacing the /usr/local/lib/libLLVM-2.7svn.so file with what you want. Linking time during shark builds and shark footprint are impressively smaller as well. Im really happy to see this functionallity in LLVM 2.7!</p> <p>The LLVM 2.7 code freeze before the 2.7 release happens in about 1.5 weeks from now and i will stay busy for some days to observe and polish the current LLVM svn trunk to be usable with openjdk-6-shark.</p> <p><strong>Edward Nevill created a ARM Jazelle RTC Thumb2 JIT reference implementation</strong></p> <p>Meanwhile I have been busy taming Sharks a new kind of Thumb2 JIT have emerged built by Edward Nevill of Cambridge Software Labs! The new Tumb2JIT have been committed into the Icedtea6 trunk and it are a working implementation of Jazelle RTC to be used by ARM Cortex-A8+ class CPUs. It wonderfull that this have been released as free software, Wow!,</p> <p>Suddenly we got three different JITs to use on ARM with OpenJDK: Cacao, Shark and T2. An opurtunity has emerged to tier them and so I did. Here comes the raw &#8220;truth&#8221; produced by Caffeine Mark 3! This will probably be the last time i will show off any Caffeine Mark 3 benchmark since it really dont give justice on real world client applications where responsiveness are more crucial than top runtime speed, nevertheless benchmarking using CM30 have always felt fun so here we go: All benchmarks running using a Sharp PC-Z1 Cortex-A8 Mobile internet tool.</p> <div id="attachment_328" class="wp-caption alignnone" style="width: 1314px"><a href="http://labb.zafena.se/wp-content/uploads/2010/02/tier-t2-shark-cacao.png"><img class="size-full wp-image-328" title="tier-t2-shark-cacao" src="http://labb.zafena.se/wp-content/uploads/2010/02/tier-t2-shark-cacao.png" alt="Tier between Edwards Thumb 2 JIT , Shark LLVM JIT and Cacao JIT: All running on OpenJDK 6 ARM" width="1304" height="299" /></a><p class="wp-caption-text">Tier between Edwards Thumb 2 JIT , Shark LLVM JIT and Cacao JIT: All running on a ARM Sharp PC-Z1 Mobile internet tool smartbook using OpenJDK 6 compiled with Icedtea6.</p></div> <p>This new T2 JIT&#8217;s main strenght are reduced jitting time, it basically cuts all jtting time to almost zero and client applications on ARM finnaly runs from tick one. This thumb2 jit makes a really nice java applet browser experience with about 15 seconds first applet startuptime on a ARM smartbook and and all usable instantly after being loaded.<br /> <a href="http://labb.zafena.se/wp-content/uploads/2010/02/java-applets-on-sharp-pc-z1-featuring-the-new-t2jit.3gp">A small 1min 12seconds .3gp movie displaying some java applets running on the Sharp PC-Z1 featuring the new thumb2jit from Icedtea6<br /> </a></p> <p>Cheers and have a great day!<br /> Xerxes</p> Thu, 25 Feb 2010 19:43:26 +0000 http://blogs.sun.com/twisti/entry/first_invokedynamic_call_on_sparc http://www.advogato.org/person/twisti/diary.html?start=35 <p>Today I successfully executed an invokedynamic call on SPARC for the first time.&nbsp; Excellent!</p> <pre>$ bin/jruby.gamma -J-XX:+UseSerialGC -J-Djruby.compile.invokedynamic=true -J-Xint -J-XX:+UnlockExperimentalVMOptions -J-XX:+EnableMethodHandles -J-XX:+EnableInvokeDynamic bench/bench_fib_recursive.rb OpenJDK Server VM (17.0-b08-internal-jvmg) for solaris-sparc JRE (1.7.0), built on Feb 25 2010 04:35:47 by "ct232829" with Workshop 5.9 VM option '+UseSerialGC' VM option '+UnlockExperimentalVMOptions' VM option '+EnableMethodHandles' VM option '+EnableInvokeDynamic' 52.813000 0.000000 52.813000 ( 52.296000) 52.824000 0.000000 52.824000 ( 52.823000) 51.808000 0.000000 51.808000 ( 51.808000) 49.740000 0.000000 49.740000 ( 49.740000) 49.450000 0.000000 49.450000 ( 49.450000) </pre> <p>MethodHandle calls already work since a couple of days and I can run the JDK <a href="http://hg.openjdk.java.net/jdk7/jdk7/jdk/file/a9b4fde406d4/test/java/dyn/MethodHandlesTest.java">MethodHandlesTest</a> without any errors:</p> <pre>$ gamma -Xinternalversion OpenJDK Server VM (17.0-b08-internal-jvmg) for solaris-sparc JRE (1.7.0), built on Feb 25 2010 04:35:47 by "ct232829" with Workshop 5.9 $ gamma -Xint -XX:+UnlockExperimentalVMOptions -XX:+EnableMethodHandles -classpath /java/devtools/share/junit/latest/junit.jar:. org.junit.runner.JUnitCore MethodHandlesTestVM option '+UnlockExperimentalVMOptions' VM option '+EnableMethodHandles' JUnit version 4.4 OpenJDK Server VM warning: JSR 292 invokedynamic is disabled in this JVM. Use -XX:+UnlockExperimentalVMOptions -XX:+EnableInvokeDynamic to enable. .IIIIII.findStatic :::::::::::.findVirtual :::::::::::::::.findSpecial ::.bind ::::::::::::::::::::::.unreflect ::::::::::::::::::::::::I.unreflectGetter .unreflectSetter .arrayElementGetter .arrayElementSetter .convertArguments ::::::.permuteArguments .spreadArguments .collectArguments .insertArguments .filterArguments .foldArguments .dropArguments .exactInvoker, genericInvoker, varargsInvoker, dynamicInvoker .guardWithTest .catchException .throwException .testCastFailure Time: 7.984 OK (23 tests) </pre> <p>JSR 292 SPARC support is on its way...<br /></p> Thu, 25 Feb 2010 13:12:45 +0000 http://rkennke.wordpress.com/?p=296 http://rkennke.wordpress.com/2010/02/24/beatles-review-with-the-beatles/ <p>Let&#8217;s continue the Beatles reviews that I started with <a href="http://rkennke.wordpress.com/2010/02/22/beatles-review-please-please-me/">Please Please Me</a> with their next album: <a href="http://www.lastfm.de/music/The+Beatles/With+the+Beatles">With The Beatles</a>.</p> <p>I remember quite well when I first listened this album for the first time. It is one of those albums that immediately bring up the mood, smell and details of that particular situation and time in my life. I was about 11 years old (I guess) and visiting my father. He had a czech print of this album, and I listened it over his great headphone. Of course I copied it to cassette (at this point cassette and reel tape was the only source of music for me, no thinking of CDs yet). I listened it over and over again in my walkman and couldn&#8217;t get enough of it. The weird hard-panned stereo mix allowed for fun experiments: if you only listen to one channel, you get voices and drums (for example) and on the other channel guitars and base, etc. Quite fun. I was a bit disappointed when I bought the CD later that it was only available in mono &#8211; now I understand that the mono version is infact much better overall. Like with the first album (and the next albums as well), the stereo mixes have some glitches that were corrected in mono (listen the start of &#8216;Roll Over Beethoven&#8217; as an example). The album blasts off with &#8216;It Won&#8217;t Be Long&#8217; (doing the Yeah shouting that they became famous for with their single She Loves You &#8211; which did not end up on the album) and keeps the energy until the last note of &#8216;Money&#8217;. Compared to their first album it is slightly more complex, they added a piano (and a rumbling piano that is) and refined their sound. Where the first album was sort of a generic beat music thing, this album is definitely Beatles (in full swing of Beatlemania). They also deliver the same basic ingredients that were also present on the first album: love songs, rockers, exotic stuff, cover versions, some George and some Ringo. My favorite is probably the last song &#8216;Money (that&#8217;s what I want)&#8217; (money seems to be a recurring theme in their career, as if they had too little: &#8216;Can&#8217;t Buy Me Love&#8217;, &#8216;Taxman&#8217;, &#8216;Baby You&#8217;re a Rich Man&#8217; and finally &#8216;You Never Give Me Your Money&#8217; and probably some others that I forgot). The cover of the album is also notable: instead of the happy-go-lucky photographs that was to be expected, it shows an arty black and white photo with the four in black polo neck pullovers. To me this is one of my favorite album covers of the Beatles. I really enjoyed listening this album today, it&#8217;s a good album for foggy days, but apparently it also works for sunny spring days like today <img src="http://s.wordpress.com/wp-includes/images/smilies/icon_smile.gif" alt=":-)" class="wp-smiley" /> Please let me know how do you like the album in the comments below, and stay tuned for the next album <a href="http://rkennke.wordpress.com/2010/03/04/beatles-review-a-hard-days-night/">A Hard Day&#8217;s Night</a>.</p> <br /> <a rel="nofollow" href="http://feeds.wordpress.com/1.0/gocomments/rkennke.wordpress.com/296/"><img alt="" border="0" src="http://feeds.wordpress.com/1.0/comments/rkennke.wordpress.com/296/" /></a> <a rel="nofollow" href="http://feeds.wordpress.com/1.0/godelicious/rkennke.wordpress.com/296/"><img alt="" border="0" src="http://feeds.wordpress.com/1.0/delicious/rkennke.wordpress.com/296/" /></a> <a rel="nofollow" href="http://feeds.wordpress.com/1.0/gostumble/rkennke.wordpress.com/296/"><img alt="" border="0" src="http://feeds.wordpress.com/1.0/stumble/rkennke.wordpress.com/296/" /></a> <a rel="nofollow" href="http://feeds.wordpress.com/1.0/godigg/rkennke.wordpress.com/296/"><img alt="" border="0" src="http://feeds.wordpress.com/1.0/digg/rkennke.wordpress.com/296/" /></a> <a rel="nofollow" href="http://feeds.wordpress.com/1.0/goreddit/rkennke.wordpress.com/296/"><img alt="" border="0" src="http://feeds.wordpress.com/1.0/reddit/rkennke.wordpress.com/296/" /></a> <img alt="" border="0" src="http://stats.wordpress.com/b.gif?host=rkennke.wordpress.com&blog=9951657&post=296&subd=rkennke&ref=&feed=1" />rkennke Wed, 24 Feb 2010 22:05:23 +0000 http://blogs.sun.com/darcy/entry/api_design_identity_and_equality http://blogs.sun.com/darcy/entry/api_design_identity_and_equality <p> When designing types to be reused by others, there are <a href="http://blogs.sun.com/darcy/entry/api_design_interfaces_versus_abstract" title="API Design: Interfaces versus Abstract Classes">reasons to favor interfaces over abstract classes</a>. One complication of using an interface-based approach stems from defining reasonable behavior for the <code>equals</code> and <code>hashCode</code> methods, especially if different implementations are intended to play well together when used in data structures like <a href="http://java.sun.com/javase/6/docs/api/java/util/Collection.html">collections</a>, in particular if an interface type is meant to serve as the key of a <a href="http://java.sun.com/javase/6/docs/api/java/util/Map.html">map</a> or as the element type of a <a href="http://java.sun.com/javase/6/docs/api/java/util/Set.html">set</a>. </p> <p> Some interfaces, like <code>CharSequence</code>, are designed to <em>not</em> be a usable type for a map key or an element type of a set: </p> <blockquote><p> <a href="http://java.sun.com/javase/6/docs/api/java/lang/CharSequence.html">[The <code>CharSequence</code>] interface</a> does not refine the general contracts of the <code>equals</code> and <code>hashCode</code> methods. The result of comparing two objects that implement <code>CharSequence</code> is therefore, in general, undefined. Each object may be implemented by a different class, and there is no guarantee that each class will be capable of testing its instances for equality with those of the other. It is therefore inappropriate to use arbitrary <code>CharSequence</code> instances as elements in a set or as keys in a map. </p></blockquote> <p> Amongst other problems, <code>CharSequence</code>s are not required to be immutable so in general there are always hazards from <a href="http://en.wikipedia.org/wiki/Time-of-check-to-time-of-use">time of check to time of use</a> conditions. </p> <p> Even if a type is not suitable as a map key, it can be fine as the type of the <em>value</em> to which a key gets mapped. Likewise, even if type cannot serve as the element type of a set, it can often still be perfectly fine as the element type of a <a href="http://java.sun.com/javase/6/docs/api/java/util/List.html">list</a>. </p> <p> Expanding on a slide from my JavaOne talk <a href="http://blogs.sun.com/darcy/resource/JavaOne/J1_2008-BOF-5874.pdf" title="Slides for JavaOne 2008 bof: Tips and Tricks..."><i>Tips and Tricks for Using Language Features in API Design and Implementation</i></a>, for interface types intended to be used as map keys or set elements, equality can be defined in several ways. First, equality can be defined solely in terms of information retrievable from methods of the interface. Alternatively, equality can be defined in terms of information retrievable via the interface methods <em>as well as</em> additional information. Finally, object identity (the <code>==</code> relation) is always a valid definition for <code>equals</code> and often a good implementation choice. </p> <p> An example of the first kind of equality definition is specified for annotation types: </p> <blockquote><p> <code><a href="http://java.sun.com/javase/6/docs/api/java/lang/annotation/Annotation.html#equals(java.lang.Object)">java.lang.annotation.Annotation.equals(Object)</a></code>:<br /> Returns true if the specified object represents an annotation that is logically equivalent to this one. In other words, returns true if the specified object is an instance of the same annotation type as this instance, all of whose members are equal to the corresponding member of this annotation, as defined below: ... </p> <p> <code><a href="http://java.sun.com/javase/6/docs/api/java/lang/annotation/Annotation.html#hashCode()">java.lang.annotation.Annotation.hashCode()</a></code>:<br /> Returns the hash code of this annotation, as defined below:<br /> The hash code of an annotation is the sum of the hash codes of its members (including those with default values), as defined below:... </p></blockquote> <p> A consequence of defining equality in this manner is that the <code>hashCode</code> algorithm must also be specified. If it were not specified, the <code>equals</code>/<code>hashCode</code> contract would be violated since <em>equal objects must have equal <code>hashCodes</code></em>. Therefore, different implementations of this style of interface must have enough information to implement the equals method and have a precise algorithm for <code>hashCode</code>. </p> <p> An annotation type is a kind of interface. At runtime, <a href="http://java.sun.com/javase/6/docs/api/java/lang/reflect/Proxy.html">dynamic proxies</a> are used to create the core reflection objects implementing annotation types, such as the objects returned by the <a href="http://java.sun.com/javase/6/docs/api/java/lang/reflect/AnnotatedElement.html#getAnnotation(java.lang.Class)"><code>getAnnotation</code></a> method. After a quick identity check, the equals algorithm used in the proxy sees if the annotation type of the two annotation objects is the same and then compares the results of the annotation type's methods. This indirection allows the annotation objects from core reflection to interact properly with other implementations of annotation objects. The annotation objects generated for annotation processing in <code>apt</code> and <code>javac</code> both use the same underlying implementation as core reflection. However, completely independent annotation implementations are fine too. For example, the code below </p> <blockquote><pre> import javax.annotation.processing.*; import javax.lang.model.SourceVersion; import java.lang.annotation.*; import java.lang.reflect.*; import java.util.*; /** * Demonstrate equality of different annotation implementations. */ @SupportedSourceVersion(SourceVersion.RELEASE_6) public class AnnotationEqualityDemonstration { static class MySupportedSourceVersion implements SupportedSourceVersion { private final SourceVersion sourceVersion; private MySupportedSourceVersion(SourceVersion sourceVersion) { this.sourceVersion = sourceVersion; } public Class annotationType() { return SupportedSourceVersion.class; } public SourceVersion value() { return sourceVersion; } public boolean equals(Object o) { if (o instanceof SupportedSourceVersion) { SupportedSourceVersion ssv = (SupportedSourceVersion) o; return ssv.value() == sourceVersion; } return false; } public int hashCode() { return (127 * "value".hashCode()) ^ sourceVersion.hashCode(); } } public static void main(String... args) { SupportedSourceVersion reflectSSV = AnnotationEqualityDemonstration.class.getAnnotation(SupportedSourceVersion.class); SupportedSourceVersion localSSV = new MySupportedSourceVersion(reflectSSV.value()); System.out.println("reflectSSV == localSSV is " + (reflectSSV == localSSV)); System.out.println("reflectSSV.equals(localSSV) is " + reflectSSV.equals(localSSV)); System.out.println("localSSV.equals(reflectSSV) is " + localSSV.equals(reflectSSV)); System.out.println("reflectSSV.getClass()equals(localSSV.getClass()) is " + reflectSSV.getClass().equals(localSSV.getClass())); System.out.println("\nreflectSSV.hashCode() is " + reflectSSV.hashCode()); System.out.println("localSSV.hashCode() is " + localSSV.hashCode()); } } </pre></blockquote> <p> when run outputs: </p> <blockquote><pre> reflectSSV == localSSV is false reflectSSV.equals(localSSV) is true localSSV.equals(reflectSSV) is true reflectSSV.getClass()equals(localSSV.getClass()) is false reflectSSV.hashCode() is 1867635603 localSSV.hashCode() is 1867635603 </pre></blockquote> <p> The second kind of equality definition is specified for the language modeling interfaces in the <code>javax.lang.model.element</code> package: </p> <blockquote><p> <code><a href="http://java.sun.com/javase/6/docs/api/javax/lang/model/element/Element.html#equals(java.lang.Object)">javax.lang.model.element.Element.equals(Object)</a></code>:<br /> Note that the identity of an element involves implicit state not directly accessible from the element's methods, including state about the presence of unrelated types. Element objects created by different implementations of these interfaces should not be expected to be equal even if "the same" element is being modeled; this is analogous to the inequality of <code>Class</code> objects for the same class file loaded through different class loaders. </p></blockquote> <p> Inside <code>javac</code>, instance control is used for the implementation classes for <code>javax.lang.model.element.Element</code> subtypes. This allows the default pointer equality to be used and allows the hashing algorithm to not be specified. Just as <a href="http://en.wikiquote.org/wiki/Heraclitus">you can't step in the same river twice</a>, the identity of an <code>Element</code> object is tied to the context in which it is created. Operationally, one consequence of this context sensitivity is that Element objects modeling "the same" type produced during different rounds of annotation processing will <em>not be equal</em> even if there are equivalent methods, fields, constructors, etc. in both types in both rounds. </p> <p> When independent implementations of an interface and <em>not</em> required to be equal to one another, the <code>hashCode</code> algorithm does <em>not</em> need to be specified, providing the implementer more flexibility. This second style of specification allows disjoint islands of implementations to be defined. </p> <p> Which style of specification is more appropriate depends on how the interface type is intended to be used. Defining interoperable implementation is more difficult and limits the ability of the interface to be retrofitted onto existing types. For example, while the Element interface and other interfaces from <a href="http://jcp.org/en/jsr/detail?id=269">JSR 269</a> were successfully implemented by classes in both <code>javac</code> and Eclipse, it would be impractical to expect Element objects from those disparate implementations to compare as equal. <a href="http://blogs.sun.com/darcy/entry/enums_and_mixins" title="Mixing-in an Enum">Mixin interfaces</a>, like <code>CharSequence</code> and <code>Closeable</code>, should be cautious in defining equals behavior if the interface is intended to be widely implemented. In some cases, a mixin interface can finesse this issue by being limited to an existing type hierarchy with already defined <code>equals</code> and <code>hashCode</code> polices. For example, the <code>Parameterizable</code> and <code>QualifiedNameable</code> interfaces added to the <code>javax.lang.model.element</code> package in JDK 7 (<a href="http://bugs.sun.com/view_bug.do?bug_id=6460529" title="Provide mixin interfaces for getQualifiedName and getTypeParameters">6460529</a>) are extensions to <code>javax.lang.model.Element</code> and therefore get to reuse the existing policies quoted above. </p> Wed, 24 Feb 2010 17:00:00 +0000 http://www.jroller.com/dgilbert/entry/be_the_change http://www.jroller.com/dgilbert/entry/be_the_change So, yesterday was the 10 year anniversary of the first release of <a href="http://www.jfree.org/jfreechart/">JFreeChart</a>, and it slipped by without me noticing! I knew it was coming up, and even checked the exact date a few weeks back, but then on the day I had so much else to do. Life is like that at the moment. Anyway, tonight as I walked home from work I decided a small celebration was in order, so I bought a bottle of <a href="http://www.marcfinewines.com/profile-New_Zealand-47.php">New Zealand sunshine</a> and...cheers! Here's to 10 years, 50+ releases, 984+ bugs, 61,525 forum posts, 1.3 million downloads, and hundreds of millions of charts generated. <br /><br /> Tue, 23 Feb 2010 21:43:28 +0000 http://rkennke.wordpress.com/?p=294 http://rkennke.wordpress.com/2010/02/22/beatles-review-please-please-me/ <p>At the end of last year, EMI/Apple re-released the whole Beatles catalogue as a series (or box sets) of remastered CDs. The Beatles were more or less my first encounter with pop music when I was 8 or so, my first self-bought CD at the age of 12 was a Beatles CD and of course, I had to go out and buy these excellent remasters, I got both the mono and stereo editions. I had many weeks now listening these CDs and re-discovering some of the stuff was quite fun, and I want to share my impressions in a short series of short reviews intermingled with some personal anecdotes. Let&#8217;s do it in order of the release of the original LPs and start with &#8216;<a href="http://www.lastfm.de/music/The+Beatles/Please+Please+Me">Please Please Me</a>&#8216;.</p> <p>I think this is quite a good career starter. Innocent, powerful, inspired, raw, rocking. It has most of the ingredients of their later Beatlemania success albums, i.e. love songs (P.S. I love you and most others), rockers (I Saw Her Standing There,&#8230;), some cover versions , a slightly more exotic song (A Taste of Honey), some Ringo (Boys), some George (Do You Want To Know a Secret), a weird sense of humor (the Beatles covering a girl group talking about &#8216;Boys&#8217;). I really always enjoy this album. It was recorded in one day, and with John having a sore throat, and it shows &#8211; positively. From the first through the last song you can literally feel the energy of those 4 relatively unknown guys, and sense that the Beatlemania is already about to start. It is what the Beatles were at this point: a hard working live band. Interesting the last song: a kamikaze version of Twist and Shout, with John shredding his vocal chords. Hilarious. It could have been a total fail (with no second chance to record it), but instead it became music history. The stereo version is mostly relevant for historical reasons, the sound beeing a bit thin and the mixes having several glitches which were corrected in the mono mixes. These mono mixes on the other hand are just great and solid rocking. All in all the album always makes for a happy-go-lucky listen on sunny afternoons, even if it is not one of the totally essential ones. Also interesting to note is also the album cover: it shows the four guys on the stairs in the EMI building. Several years later they did the exact same scene again, now with long hair, for the planned last album (Get Back, which should become Let it Be). Both pictures would later be used for the red and blue best of double albums.</p> <p>Next one up will be <a href="http://rkennke.wordpress.com/2010/02/24/beatles-review-with-the-beatles/">With The Beatles</a>. Stay tuned. Please tell me what you think about the album in the comments.</p> <br /> <a rel="nofollow" href="http://feeds.wordpress.com/1.0/gocomments/rkennke.wordpress.com/294/"><img alt="" border="0" src="http://feeds.wordpress.com/1.0/comments/rkennke.wordpress.com/294/" /></a> <a rel="nofollow" href="http://feeds.wordpress.com/1.0/godelicious/rkennke.wordpress.com/294/"><img alt="" border="0" src="http://feeds.wordpress.com/1.0/delicious/rkennke.wordpress.com/294/" /></a> <a rel="nofollow" href="http://feeds.wordpress.com/1.0/gostumble/rkennke.wordpress.com/294/"><img alt="" border="0" src="http://feeds.wordpress.com/1.0/stumble/rkennke.wordpress.com/294/" /></a> <a rel="nofollow" href="http://feeds.wordpress.com/1.0/godigg/rkennke.wordpress.com/294/"><img alt="" border="0" src="http://feeds.wordpress.com/1.0/digg/rkennke.wordpress.com/294/" /></a> <a rel="nofollow" href="http://feeds.wordpress.com/1.0/goreddit/rkennke.wordpress.com/294/"><img alt="" border="0" src="http://feeds.wordpress.com/1.0/reddit/rkennke.wordpress.com/294/" /></a> <img alt="" border="0" src="http://stats.wordpress.com/b.gif?host=rkennke.wordpress.com&blog=9951657&post=294&subd=rkennke&ref=&feed=1" />rkennke Mon, 22 Feb 2010 19:28:04 +0000 http://blogs.sun.com/darcy/entry/everything_older_is_newer_once http://blogs.sun.com/darcy/entry/everything_older_is_newer_once <p> Catching up on writing about more numerical work from years past, the <a href="http://www.ibm.com/developerworks/java/library/j-math2.html" title="Java's new math, Part 2: Floating-point numbers">second article</a> in a two-part series finished last year discusses some low-level floating-point manipulations methods I added to the platform over the course of JDKs 5 and 6. Previously, I published a <a href="http://blogs.sun.com/darcy/entry/everything_old_is_new_again" title="Everything Old is New Again">blog entry reacting to</a> the <a href="http://www.ibm.com/developerworks/java/library/j-math1/index.html" title="Java's new math, Part 1: Real numbers">first part</a> of the series. </p> <p> JDK 6 enjoyed several numerics-related library changes. Constants for <code>MIN_NORMAL</code>, <code>MIN_EXPONENT</code>, and <code>MAX_EXPONENT</code> were added to the <code>Float</code> and <code>Double</code> classes. I also added to the <code>Math</code> and <code>StrictMath</code> classes the following methods for low-level manipulation of floating-point values: </p> <ul> <li><code><a href="http://java.sun.com/javase/6/docs/api/java/lang/Math.html#copySign(double,%20double)"> public static double copySign(double magnitude, double sign)</a></code> <li><code><a href="http://java.sun.com/javase/6/docs/api/java/lang/Math.html#getExponent(double)">public static int getExponent(double d)</a></code> <li><code><a href="http://java.sun.com/javase/6/docs/api/java/lang/Math.html#nextAfter(double,%20double)">public static double nextAfter(double start, double direction)</a></code> <li><code><a href="http://java.sun.com/javase/6/docs/api/java/lang/Math.html#nextUp(double)">public static double nextUp(double d)</a></code> <li><code><a href="http://java.sun.com/javase/6/docs/api/java/lang/Math.html#scalb(double,%20int)">public static double scalb(double d, int scaleFactor)</a></code> </li></li></li></li></li></ul> <p> There are also overloaded methods for <code>float</code> arguments. In terms of the <a href="http://en.wikipedia.org/wiki/IEEE_754-1985">IEEE 754 standard from 1985</a>, the methods above provide the core functionality of the <i>recommended functions</i>. In terms of the <a href="http://en.wikipedia.org/wiki/IEEE_754-2008">2008 revision to IEEE 754</a>, analogous functions are integrated throughout different sections of the document. </p> <p> While a student at Berkeley, I wrote a <a href="http://www.jddarcy.org/Research/ieeerecd.pdf">tech report</a> on algorithms I developed for an earlier implementation of these methods, an implementation written many years ago when I was a summer intern at Sun. The <a href="http://hg.openjdk.java.net/jdk7/tl/jdk/file/84792500750c/src/share/classes/sun/misc/FpUtils.java" title="sun.misc.FpUtils as of Feb. 20, 2010">implementation of the recommended functions in the JDK<a> is a refinement of the earlier work, a refinement that simplified code, added <a href="http://hg.openjdk.java.net/jdk7/tl/jdk/file/84792500750c/test/java/lang/Math/IeeeRecommendedTests.java" title="IeeeRecommendedTests.java regression test as of Feb. 20, 2010">extensive</a> and <a href="http://blogs.sun.com/darcy/entry/test_where_the_failures_are" title="Test where the failures are likely to be">effective</a> unit tests, and sported better performance in some cases. In part the simplifications came from <em>not</em> attempting to accommodate IEEE 754 features not natively supported in the Java platform, in particular rounding modes and sticky flags. </a></a></p> <p> The primary purpose of these methods is to assist in in the development of math libraries in Java, such as the recent <a href="http://hg.openjdk.java.net/jdk7/jdk7/jdk/rev/ad1e30930c6c">pure Java implementation of floor and ceil</a> (<a href="http://bugs.sun.com/view_bug.do?bug_id=6908131" title="Pure Java implementations of StrictMath.floor(double) & StrictMath.ceil(double)">6908131</a>). This expected use-case drove certain API differences with the functions sketched by IEEE 754. For example, the <code>getExponent</code> method simply returns the unbiased value stored in the exponent field of a floating-point value rather than doing additional processing, such as computing the exponent needed to normalized a subnormal number, additional processing called for in some flavors of the 754 <code>logb</code> operation. Such additional functionality can actually slow down math libraries since libraries may not benefit from the additional filtering and may actually have to undo it. </p> <p> The <code>Math</code> and <code>StrictMath</code> specifications of <code>copySign</code> have a small difference: the <a href="http://java.sun.com/javase/6/docs/api/java/lang/StrictMath.html#copySign(double,%20double)" title="java.lang.StrictMath.copySign"><code>StrictMath</code> version</a> always treats NaNs as having a positive sign (a sign bit of zero) while the <a href="http://java.sun.com/javase/6/docs/api/java/lang/Math.html#copySign(double,%20double)" title="java.lang.Math.copySign"><code>Math</code> version</a> does not impose this requirement. The IEEE standard does not ascribe a meaning to the sign bit of a NaN and difference processors have different conventions NaN representations and how they propagate. However, if the source argument is not a NaN, the two <code>copySign</code> methods will produce equivalent results. Therefore, even if being used in a library where the results need to be completely predictable, the faster <code>Math</code> version of <code>copySign</code> can be used as long as the source argument is known to be numerical. </p> <p> The recommended functions can also be used to solve a little floating-point puzzle: generating the interesting limit values of a floating-point format just starting with constants for <code>0.0</code> and <code>1.0</code> in that format: </p> <ul> <li><p><code>NaN</code> is <code>0.0/0.0</code>. </p> <li><p><code>POSITIVE_INFINITY</code> is <code>1.0/0.0</code>. </p> <li><p><code>MAX_VALUE</code> is <code>nextAfter(POSITIVE_INFINITY, 0.0)</code>. </p> <li><p><code>MIN_VALUE</code> is <code>nextUp(0.0)</code>. </p> <li><p><code>MIN_NORMAL</code> is <code>MIN_VALUE/(nextUp(1.0)-1.0)</code>. </p> </li></li></li></li></li></ul> Sun, 21 Feb 2010 05:41:48 +0000 http://weblog.ikvm.net/PermaLink.aspx?guid=ac55cc6d-8a72-469b-98c6-84d19ec309b8 http://weblog.ikvm.net/PermaLink.aspx?guid=ac55cc6d-8a72-469b-98c6-84d19ec309b8 <p> I fixed a major bug in the automagic .NET serialization support. </p> <p> Changes: </p> <ul> <li> Updated version to 0.42.0.5.</li> <li> Fix for bug #<a href="https://sourceforge.net/tracker/?func=detail&atid=525264&aid=2946842&group_id=69637">2946842</a>.</li> </ul> <p> Binaries available here: <a href="http://www.frijters.net/ikvmbin-0.42.0.5.zip">ikvmbin-0.42.0.5.zip</a><br /><br /> Sources: <a href="http://www.frijters.net/ikvm-0.42.0.5.zip">ikvm-0.42.0.5.zip</a>, <a href="http://www.frijters.net/openjdk6-b16-stripped.zip">openjdk6-b16-stripped.zip</a></p> <img width="0" height="0" src="http://weblog.ikvm.net/aggbug.ashx?id=ac55cc6d-8a72-469b-98c6-84d19ec309b8" /> Fri, 19 Feb 2010 08:40:08 +0000 http://blog.fuseyism.com/?p=94 http://blog.fuseyism.com/index.php/2010/02/18/openjdk6-b18-released-and-in-icedtea6/ <p>Joe Darcy released <a href="http://blogs.sun.com/darcy/entry/openjdk_6_b18_source_bundle">OpenJDK6 b18</a> yesterday evening and this is now integrated with the <a href="http://icedtea.classpath.org/hg/icedtea6">latest IcedTea6 from Mercurial</a>.</p> <p>To build:</p> <pre> $ hg clone http://icedtea.classpath.org/hg/icedtea6 $ mkdir icedtea6-build $ cd icedtea6-build $ ../icedtea6/configure $ make </pre> <p>Then grab a beverage of your choice and wait a while&#8230; I recommend adding <code>--with-parallel-jobs</code> to the configure invocation if you have a multi-core machine.</p> <p>Once built, you will have a build of OpenJDK6 which can use the Nimbus Look and Feel as explained in <a href="http://blog.fuseyism.com/index.php/2009/04/09/nimbus-arrives/">my previous blog</a></p> Thu, 18 Feb 2010 18:23:52 +0000 http://blogs.sun.com/darcy/entry/openjdk_6_b18_regression_tests http://blogs.sun.com/darcy/entry/openjdk_6_b18_regression_tests <p> Running with the usual <tt>jtreg</tt> flags, <tt>-a -ignore:quiet</tt> in all repositories and adding <tt>-s</tt> for <tt>langtools</tt>, the basic regression test results on Linux for <a href="http://blogs.sun.com/darcy/entry/openjdk_6_b18_source_bundle">OpenJDK 6 build 18</a> are: </p> <ul> <li><p><a href="http://blogs.sun.com/darcy/resource/OpenJDK_6/b18-hotspot-linux-summary.txt">HotSpot</a>, 24 tests passed. </p> <li><p><a href="http://blogs.sun.com/darcy/resource/OpenJDK_6/b18-langtools-linux-summary.txt">Langtools</a>, 1,355 tests passed. </p> <li><p><a href="http://blogs.sun.com/darcy/resource/OpenJDK_6/b18-jdk-linux-summary.txt">JDK</a>, 3,148 tests pass, 19 fail, and 2 have errors. </p> </li></li></li></ul> <p> All the HotSpot tests continue to pass: </p> <blockquote> <pre> 0: b17-hotspot/summary.txt pass: 24 1: b18-hotspot/summary.txt pass: 24 No differences </pre> </blockquote> <p> In <tt>langtools</tt> all the tests continue to pass and one test was added: </p> <blockquote> <pre> 0: b17-langtools/summary.txt pass: 1,354 1: b18-langtools/summary.txt pass: 1,355 0 1 Test --- pass tools/javac/T6855236.java 1 differences </pre> </blockquote> <p> And in <tt>jdk</tt>, a few dozen new tests were added in b18 and the existing tests have generally consistent results, with a number of long-standing test failures corrected by Pavel Tisnovsky. The test run below was executed outside of Sun's and Oracle's wide-area network using the following contents for the testing network configuration file: <blockquote><pre> host=icedtea.classpath.org refusing_host=ns1.gnu.org far_host=developer.classpath.org </pre></blockquote> <p> The file location to use for the networking configuration can be set by passing a <code>-e JTREG_TESTENV=<i>Path to file</i></code> option to <code>jtreg</code>. </p> </p> <blockquote> <pre> 0: b17-jdk/summary.txt pass: 3,118; fail: 26 1: b18-jdk/summary.txt pass: 3,148; fail: 19; error: 2 0 1 Test --- pass com/sun/java/swing/plaf/nimbus/Test6741426.java --- pass com/sun/java/swing/plaf/nimbus/Test6849805.java --- pass com/sun/jdi/BreakpointWithFullGC.sh --- pass com/sun/jdi/ResumeOneThreadTest.java --- pass com/sun/jdi/SimulResumerTest.java --- pass demo/jvmti/compiledMethodLoad/CompiledMethodLoadTest.java fail pass java/awt/Frame/DynamicLayout/DynamicLayout.java fail pass java/awt/Frame/MaximizedToIconified/MaximizedToIconified.java fail pass java/awt/Frame/ShownOffScreenOnWin98/ShownOffScreenOnWin98Test.java fail pass java/awt/Frame/UnfocusableMaximizedFrameResizablity/UnfocusableMaximizedFrameResizablity.java --- pass java/awt/GraphicsDevice/CloneConfigsTest.java fail pass java/awt/GridLayout/LayoutExtraGaps/LayoutExtraGaps.java fail pass java/awt/Insets/CombinedTestApp1.java fail pass java/awt/KeyboardFocusmanager/TypeAhead/ButtonActionKeyTest/ButtonActionKeyTest.html fail pass java/awt/KeyboardFocusmanager/TypeAhead/MenuItemActivatedTest/MenuItemActivatedTest.html fail pass java/awt/KeyboardFocusmanager/TypeAhead/SubMenuShowTest/SubMenuShowTest.html fail pass java/awt/KeyboardFocusmanager/TypeAhead/TestDialogTypeAhead.html pass fail java/awt/Multiscreen/LocationRelativeToTest/LocationRelativeToTest.java fail pass java/awt/TextArea/UsingWithMouse/SelectionAutoscrollTest.html fail pass java/awt/Toolkit/ScreenInsetsTest/ScreenInsetsTest.java pass --- java/awt/Window/AlwaysOnTop/AlwaysOnTopEvenOfWindow.java pass fail java/awt/Window/GrabSequence/GrabSequence.java fail pass java/awt/grab/EmbeddedFrameTest1/EmbeddedFrameTest1.java pass fail java/awt/print/PrinterJob/ExceptionTest.java --- pass java/lang/ClassLoader/UninitializedParent.java pass fail java/net/ipv6tests/TcpTest.java pass fail java/nio/channels/SocketChannel/AdaptSocket.java pass fail java/nio/channels/SocketChannel/LocalAddress.java pass fail java/nio/channels/SocketChannel/Shutdown.java pass fail java/rmi/transport/pinLastArguments/PinLastArguments.java --- pass java/util/TimeZone/OldIDMappingTest.sh --- pass java/util/TimeZone/TimeZoneDatePermissionCheck.sh --- pass javax/swing/JButton/6604281/bug6604281.java fail pass javax/swing/JTextArea/Test6593649.java --- pass javax/swing/Security/6657138/ComponentTest.java --- pass javax/swing/Security/6657138/bug6657138.java --- pass javax/swing/ToolTipManager/Test6657026.java --- pass javax/swing/UIManager/Test6657026.java --- pass javax/swing/plaf/basic/BasicSplitPaneUI/Test6657026.java --- pass javax/swing/plaf/metal/MetalBorders/Test6657026.java --- pass javax/swing/plaf/metal/MetalBumps/Test6657026.java --- pass javax/swing/plaf/metal/MetalInternalFrameUI/Test6657026.java --- pass javax/swing/plaf/metal/MetalSliderUI/Test6657026.java pass error sun/java2d/OpenGL/GradientPaints.java pass fail sun/rmi/transport/proxy/EagerHttpFallback.java --- pass sun/security/provider/certpath/DisabledAlgorithms/CPBuilder.java --- pass sun/security/provider/certpath/DisabledAlgorithms/CPValidatorEndEntity.java --- pass sun/security/provider/certpath/DisabledAlgorithms/CPValidatorIntermediate.java --- pass sun/security/provider/certpath/DisabledAlgorithms/CPValidatorTrustAnchor.java pass error sun/security/ssl/javax/net/ssl/NewAPIs/SessionTimeOutTests.java --- pass sun/security/tools/jarsigner/emptymanifest.sh --- pass sun/security/util/DerValue/BadValue.java fail pass sun/tools/jhat/HatHeapDump1Test.java fail pass sun/tools/native2ascii/NativeErrors.java 54 differences </pre> </blockquote> Wed, 17 Feb 2010 17:35:00 +0000 http://blogs.sun.com/darcy/entry/openjdk_6_b18_source_bundle http://blogs.sun.com/darcy/entry/openjdk_6_b18_source_bundle <p> On February 16, 2010 the <a href="http://download.java.net/openjdk/jdk6/promoted/b18/openjdk-6-src-b18-16_feb_2010.tar.gz">source bundle</a> for OpenJDK 6 b18 was published. </p> <p> Major changes in this build include the latest round of security fixes and, courtesy of Andrew John Hughes, a backport of the Nimbus look and feel from JDK 7. In addition, a <a href="http://blogs.sun.com/darcy/entry/jdk_7_new_component_delivered" title="JDK 7: New Component Delivery Model Delivered">new delivery model</a> is being used for the <code>jaxp</code> and <code>jax-ws</code> components. </p> <p> A detailed list of all the changes is <a href="http://blogs.sun.com/darcy/resource/OpenJDK_6/openjdk6-b18-changes-summary.html">also available</a>. </p> Wed, 17 Feb 2010 17:30:00 +0000 http://www.jroller.com/neugens/entry/heavy_rain http://www.jroller.com/neugens/entry/heavy_rain <p>There&#8216;s a lot of hype around <a href="http://en.wikipedia.org/wiki/Heavy_Rain">this title</a>. I gave a look at the trailers and I had the feeling that the game play was so similar to very old games (1983!) such as Dragon&#8216;s Lair or Space Quest.</p> <p>Today, I finally played the demo and I still have constrasting feelings&#8230; Is it cool? Yeah&#8230; I think it is, really: it&#8216;s like playing a film, full of dark mood, beautiful scenes and colours, and a really intriguing story.</p> <p>The demo shows some funny behaviour, for example, when not triggering a cut scene (that is, 90% of the time <strong>you are</strong> in a cut scene), the non playing characters (NPEs) look a bit dumb. In fact, you have the feeling that everything is a bit fake, because the interaction takes place only when is supposed to, and you find yourself wandering around the area without knowing what to do when you have no more options left, with the NPCs staring a wall with idiotic espression :)</p> <p>There is a nice system that tries to address this issue and adds even more of a nice movie mood to the game: you can listen to your character&#8216;s thoughts, and they act like an offscreen narrator, very cool I have to say.</p> <p>The game play is almost non existent, though, you press one button or two when some HUDs pops up and inevitably mess with the Sixaxis controller&#8230; On the other hand, is really beautiful to watch. I suggest to wait a full review on Gamespot, but the game is cool so far.</p> <p>I confirm that is the same kind of game as Dragon&#8216;s Lair and Space Ace, be warned if you don&#8216;t like this kind of stuff.</p> <p><center><br /> <br /> </center></p> <p><center><br /> <br /> </center></p> <p><center><br /> <br /> </center></p> Mon, 15 Feb 2010 21:37:25 +0000