Java Technology Community

  *(void **) (&numa_node_to_cpus) = dlsym(handle, "numa_node_to_cpus"); and a call is made like
          |
                if ( 0 == numa_node_to_cpus(i, cpubuf, sizeof(BUF)) ) {
                |
                |

typedef unsigned long BUF[64];
and BUF cpubuf;

numa_node_to_cpus_V1
and 
numa_node_to_cpus_V2

and there is a generic method "numa_node_to_cpus" which does the necessary conversion/calculations 
and then calls the appropriate version of the API. 

Here comes the problem "may be the parameters passed by the application (which was designed considering 
V1 of this API) are not appropriate for V2. 
This is known as versioning issue, this is usually taken care by the Kernel Developer community but 
sometimes gets missed. 

dlsym will always call the latest version available (modifying the args passed appropriately) but if 
this doesn't work out well. Try using dlvsym() instead of dlsym to get the exact version of API 
required. 

Hope this helps. There is a bug which has already been raised for numa_node_to_cpus versioning issue. 
Hope this helps.

Deepti.

 

 M E M B E R   S P O T L I G H T

---

Member Spotlight :  : Hemanth HM 

 

In his own words, Hemanth is that kind of a person , who admits he doesn't know it , if he really doesn't know it and will not stop there , but rather hunt down and always loves to sit for long hours learning new things and trying to do something revolutionary. He believes in the quote " IF u can dream it you can do it " , though he is a Computer science graduate , he is interested in art and philosophy.Also does some translations in launchpad.

  

---

Q Tell us a bit about yourself & your accomplishments.

As a kid, I always had imagined that computers are devices which answer any questions we have, solves any problem we have in life! No wonder this curiosity has put me on a high adrenaline rush, that is still making me  explore the extraordinary field  of computers.
Defining oneself is the hardest thing to do, asked my friends, most of them said I’m just a computer geek, the relative term is always confusing, I would define myself as a person who always likes to face challenges in life and has always tried to do something different. Completing my bachelors in computer science , I was much more adept than the normal curriculum and was more interested in doing new things by my own. Accomplishments indeed is a very relative term! The below are a few noticeable:

• Won the top speaker award in IBM Develothon 2010.
• First prize in State level technical paper presentation conducted by Infosys.
• Gave more than 50 ideas to Google wave, a few did got implemented.
• 201th best contributor in the world of Ubuntu brainstrom.
• Took part in the first ever open-web p2pu course from Mozilla.
• Gold medal in state level debate competition.
• One of the top 100 selected members in Adobe Flex boot camp.
• Mentor approval for GSOC for a true idea called "Ants and Algorithm".

Q. You were announced as the Best Speaker at IBM Develothon 2010, Bangalore, how was the experience?

This was the third time in a row I attended IBM developerWorks Unconference as a speaker, I have seen it evolving. This time there was pre talk voting, where the audience had to decide if they liked to hear someone speak about a particular topic. Crossing over that in itself was a tough task, especially amongst many on-spot entries. It’s always tricky to get the crowd mentality, sometimes the overwhelming preparation is just void and sometimes an extempore wins the crowd!!

Its been quite an epic victory, I was all excited [ most of the time I am when it related to speaking in front of a bombastic crowd ] . I had already updated my social networks as most of them would have saying, “Me selected to be one of the speakers in IBM develothon, wish me luck”, after the pre talk voting. Then when it was for the audience to select who was the best for that day amongst the lot.  It was a roller coaster ride, seeing so many people agreeing with my thoughts. It made me feel elated and got great opportunity to network during the yummy lunch time.
I have blogged it in detail here: http://www.h3manth.com/content/ants-journey-planet-called-ibm

Q. Do you have any favorite technology related websites/books that you can recommend to others?

Websites : {techcrunch, slashdot,news.ycombinator,reedit, mashable,readwriteweb}.com

Books : {founder,coder}@work, Design Patterns: Elements of Reusable Object-Oriented Software, Surely You're Joking, Mr. Feynman! and if you have read that all, for life time reading there is “The Art of Computer Programming (TAOCP)” for all of us :).

Q. What is the best advice you have ever been given?

The best advice, that my mother gave me once was, as humans everyone will have good and bad qualities, learn to see only the good qualities in them, I though it was just a cliche, but when I tried to apply it, I saw a different world all together!

Q. How do you find developerWorks useful ?

The very first article I read on developerWorks was that in the linux section, it was happy read.  Mydeveloperworks is rather drawing my attention these days with many renowned geeks blogging on their expertise. It is indeed a  great repository of good stuff.
It would be more nice if  there is live interaction with everyone on a simple chat application would be fun.

Q. Your blog has a vast amount of great content, what advice would you give a blogger trying to find new stories for their blog and producing new great content everyday?

First and foremost, write on everything you do which is in unison with your blogs genre, have a deadline, be self motivated and never think how others would react. As everyone is unique, we must find our own way and add variety of flavours in all our writings, as of my philosophy is to just write what I have tried, in an particular topic and not to worry about getting traffic into the blog and generating comments and for the fact of it when something is interesting and new, indeed people will like it, but after blogging a new post its much necessary at least for a few of your social media friends to know it, sharing is life.

Blogger block indeed happens to every blogger, few things I have followed is to lead the mind relax in a cool room start brainstorming on a particular topic, do look out for resources if already someone has done it try to think of a better ways of doing it.

Q. How do you wish to see your career shape in future?

Completing my degree in 2009 and a few start-up experience with me, I am eager to ply my potential to the fullest. Moving on  I’m confident enough to rely on my technical and articulation skills to achieve full satisfaction in whatever I get to work on.

Thanks for the candid responses Hemanth!

Computers may keep getting faster and more powerful, yet many organizations are still hampered by the inconsistent performance of their systems. While today’s systems are capable of processing most transactions within a matter of milliseconds, there is still a percentage of these transactions that will take an order of magnitude longer to complete, because systems temporarily slow down from extraneous or internal housekeeping operations that may tax system resources.

For a growing number of organizations today, such unpredictability is disruptive, costly and unacceptable. A trading desk at a brokerage firm cannot ensure the integrity of its transactions if some are slowed because of a systems bottleneck. Financial services organizations are under pressure to assure that both front-office and middle-office transactions not only are executed at blazing speed, but also are consistently fast across the board – or else face the scrutiny of regulatory agencies.

That is why real-time processing with determinism – or the ability to deliver predictable, consistent results – is becoming a necessity. Now, thanks to new developments in the market, real-time processing capabilities are available through standardized software solutions that don’t require massive investments in skills or additional hardware.

WebSphere Real Time offers a fast and deterministic version of the world’s best known development language.

Real-Time Java-based applications can be deployed with minimal impact on current configurations – with no need to re-learn a special-purpose language. WebSphere Real Time now makes it simple and affordable for organizations of all types to build out realtime operations with predictable performance.

WebSphere Real Time enables organizations to redirect critical resources to core business requirements rather than expending time and money in supporting customer, low-latency systems.

Programmers no longer have to rely on languages such as C, C++ or ADA 95 for real-time programming. This Java platform now represents a viable alternative environment for highly deterministic, distributed, real-time applications in critical system applications, ranging from command and control, weapons, industrial automation and financial systems to telecommunication infrastructures.

Financial services firms have been buying the latest and greatest technology for years, in an effort to manage an explosion of data, support complex transactions, meet stringent regulatory requirements, and compete in fast-changing markets. Functions such as value weighted average pricing (VWAP), derivatives pricing, and pre- and post-trade short-running analytic programs can benefit from real-time. In this industry, the ability to analyze and leverage the latest and freshest data means competitive advantage. To meet this challenge, firms are embracing high-performance trading and analytics systems.

Enterprises leveraging real-time capabilities can respond more quickly than their competition to new information and changing market conditions. Running their time-sensitive mission critical applications on Real-Time Linux, Java, and WebSphere middleware not only reduces process dispatch latencies, but also gives enterprises the time advantage they need to reduce the risks of financial losses, and retain leadership in their markets.

While financial services organizations are seeing the initial benefits of Real-Time Linux and Java, there are numerous advantages for other industries, from government to healthcare to manufacturing. Real-time processing will provide predictability to applications such as realtime product simulations, language translation, and audio/video streaming, among others. For many industries, the time is NOW to move.

Why do we want to solve problems quickly?

• It means a lower Total Cost of Ownership (TCO) for us and our customers.
• Problem determination and resolution has become a daunting task as more of today’s solutions involve complex collections of products and applications deployed in heterogenous environments
• Developing and deploying new solutions gets delayed by maintenance of diverse existing systems
• 25-50%  of  time is spent in problem determination and resolution
• The skills needed to do manual cross-product problem determination are scarce and expensive.

In this age of complex and integrated systems and short cycle times of deployment, the ability to respond to business demands in a timely manner is becoming critical. Pro-active problem determination, quick and easy access to relevant information, reduced turnaround times on interactions with support organizations are key - client "self assist" is the "buzzword"

In the recent times a wide array of new tooling has emerged from the IBM Java Technology Center and WebSphere Serviceability teams that enable developers to debug Java Runtime issues in a convenient way. A  key focus area for IBM  is to make the user experience with these tools a convenient one. Tools should be easy to obtain, available from a single source and easy to update. The IBM Support Assistant (www.ibm.com/software/support/isa) is a free local workbench that includes rich features and serviceability tools for quick resolution to problems.  All the Java tools delivered through the IBM Support Assistant provide the capabilities of :

- "Visualization"                           Provide different graphical views for a diagnostic data input (a view of increased java heap usage over time for example)

- "Analysis"                                   Analysis reports based on the data analyzed (analysis of the increased heap usage over time indicating a memory leak for example)

-  "Recommendations"              Recommendations and suggestions to resolve the observed problem (Analysis of heapdumps to identify the cause of memory leak for example)

• Garbage Collection and Memory Visualizer 

The Garbage Collection and Memory Visualizer is available as a plug-in to IBM Support Assistant (ISA).   It analyzes verbose GC output to provide plots, summaries and recommendations.  The tool profiles heap usage, heap sizes, pause times and many other properties. Flexibility of comparing multiple logs in the same plots and many views on data (reports, graphs, tables) are available. This is a powerful tool to debug performance bottlenecks in the Java application due to Garbage Collection.

• Memory Analysis Tool (MAT)

Memory Leaks in Java are a consequence of non obvious programming errors - and debugging memory leaks is not an exact science. The Eclipse Memory Analyzer is a fast and feature-rich Java heap analyzer that helps you find memory leaks and reduce memory consumption. The Memory Analyzer was developed to analyze productive heap dumps with hundreds of millions of objects. Once the heap dump is parsed, you can re-open it instantly, immediately get the retained size of single objects and quickly approximate the retained size of a set of objects.

• The IBM® Monitoring and Diagnostic Tools for Java™ – Health Center™

Health Center is a lightweight monitoring tool (with a performance overhead of not more than 2-3%)  which allows running Java™ Vitual Machines to be observed and health-checked. The Health Center enables insights into general system health, application and garbage collection activity. Developers, performance engineers and practitioners can use the IBM Health Center tool to quickly identify any performance bottlenecks which is specifically helpful in an agile development environment. Designed to attach to a running Java process to explore what it is doing, how it is behaving, and what you could do to make it happier.

More  information on these tools can be found at: http://www.ibm.com/developerworks/java/jdk/tools/index.html

*Java is the registered trademark of Oracle Inc.

1. All exceptions must be a child of Throwable.
2. If you want to write a checked exception that is automatically enforced by the Handle or Declare Rule, you need to extend the Exception class.
3. If you want to write a runtime exception, you need to extend the RuntimeException class.

class MyException extends Exception{ 
 }

Example:

 // File Name InsufficientFundsException.java
 import java.io.*;

 public class InsufficientFundsException extends Exception 
 {
   private double amount;
   public InsufficientFundsException(double amount)
   {
      this.amount = amount;
   } 
   public double getAmount()
   {
      return amount;
   }
 }

 // File Name CheckingAccount.java
 import java.io.*;

 public class CheckingAccount
 {
   private double balance;
   private int number;
   public CheckingAccount(int number)
   {
      this.number = number;
   }
   public void deposit(double amount)
   {
      balance += amount;
   }
   public void withdraw(double amount) throws InsufficientFundsException 
   {
      if(amount <= balance)
      {
         balance -= amount;
      }
      else
      {
         double needs = amount - balance;
         throw new InsufficientFundsException(needs); 
      }
   }
   public double getBalance()
   {
      return balance;
   }
   public int getNumber()
   {
      return number;
   }
 }

 // File Name BankDemo.java
 public class BankDemo
 {
   public static void main(String [] args)
   {
      CheckingAccount c = new CheckingAccount(101);
      System.out.println("Depositing $500...");
      c.deposit(500.00);
      try
      {
         System.out.println("\nWithdrawing $100..."); 
         c.withdraw(100.00);
         System.out.println("\nWithdrawing $600...");
         c.withdraw(600.00);
      }catch(InsufficientFundsException e)
      {
         System.out.println("Sorry, but you are short $"
                                  + e.getAmount());
         e.printStackTrace();
      }
    }
 }
 

Depositing $500...

Withdrawing $100...

Withdrawing $600...
Sorry, but you are short $200.0



To follow me and know more about programming stuff,



Facebook : http://www.facebook.com/code2learn

Website : http://www.code2learn.com
InsufficientFundsException
        at CheckingAccount.withdraw(CheckingAccount.java:25)
        at BankDemo.main(BankDemo.java:13)

Import button

 

import stanford.karel.*;

public class CollectNewspaperKarel extends Karel{

    public void run(){
          move();
          turnRight();
          move();
          turnLeft();
          move();
          pickBeeper();
    }

    public void turnRight(){
          turnLeft();
          turnLeft();
          turnLeft();
    }
} 

• Incorrect sequence of acquiring multiple locks often results in deadlocks
• Excessive locking can cause high CPU issues.
• Improper/frequent lock acquires and prolonged lock acquires can cause performance issues.

Let’s try and understand basic terms pertaining to Locking in the IBM J9 Java Virtual Machine which is based on modified “Tasuki Locks”.

Let's look at locking at the Java layer. The Java programming language provides two basic synchronization idioms: synchronized methods and synchronized statements. A method can be defined as synchronized, in which case, the particular java object on which the method is called, will be locked. Similarly, synchronized() statements can be used to lock any Java objects.

Now let's take a look at the synchronization at native level. In JNI applications, the synchronization is achieved by MonitorEnter() and MonitorExit() methods on the object.

 (*env)->MonitorEnter(env,obj);

    … code…

if (object.lockWord.flat) {

                        for (int k = 0; k < spin3; k++) {

                                    for (int j = 0; j < spin2; j++) {

                                                AcquireLock_with_objectflagupdate();

                                                return;

                                                CPU_pause();

                                                for (int i = 0; i < spin1; i++) {

                                                            ;  /* do nothing */

                                                }

                                    }

                        thread.yield();

                        }

}

If the thread exhausts 3 tier spin, it will be made to sleep until the lock is freed. The lock will now be considered as a contended lock (for it was busy for considerable period) and will be inflated, once it is freed. As soon as the lock is freed, a native level JVM system monitor structure will be created and the object flag will be updated with the address of native structure along with the indicator bit set to 1 (indicating the object is inflated). This is called an inflated monitor/lock.

On a contended lock, there could be multiple threads that could be waiting. The 32 bit flag is not capable of holding all the required information about waiting threads, entering threads and so on. So we create a JVM structure to hold this information during Inflation and update the Object. The JVM system monitor structure holds the Operating System mutex information, owner thread id, ids of the threads that are waiting on the lock and other related information.

In the subsequent blog posts, I will take you through the changes in Locking mechanism in R626 and how to identify and interpret the locking related issues.

In today’s complex and integrated environments, the ability to determine the “health” of an application quickly assumes high importance. The IBM Health Center is a light-weight profiling tool that provides a comprehensive view of the “health” of various subsystems for any Java based application.

Developers, performance engineers and practitioners can use the IBM Health Center tool to quickly identify any performance bottlenecks which is specifically helpful in an agile development environment. Designed to attach to a running Java process to explore what it is doing, how it is behaving, and what you could do to make it happier.

The IBM Health Center attempts to answer some of the following common questions that developers, performance engineers, service personnel and WebSphere administrators often ask:-

What is my Java application doing ?

Why is it doing that ?

Why is my application going so slowly ?

How can I make it go faster ? Is my application scaling well ?

Is our algorithm sensible ?

Do we need to tune the Java Virtual Machine ?

Is my configuration sensible ?

Is the system stable ?

Have I got a memory leak ?

Is the application about to crash ?

Classes, Environment, Garbage Collection, Locking and Method Profiling, Native Memory, I/O are areas of JVM activity which can be viewed and receive recommendations on, from the Health Center tool. The Health Center summary will indicate if there are any potential problems with the particular subsystem (indicated in Red color), or tuning suggestions for optimizing the subsystem further (indicated in Amber) and an indication of a healthy subsystem (with no problems) denoted in Green color

The IBM Health Center not only provides a visualization into the various subsystems of the JVM from a performance and reliability perspective but also provides a set of recommendations that can be applied to alleviate the identified problems. The performance overhead of the tool is negligible and can be deployed on production systems.

The IBM Health Center is available via the IBM Support Assistant framework. (www.ibm.com/software/support/isa/ )

The latest version of Health Center (version 1.3) comes with some very useful new features.  Options are available now in Health Center for you to generate dumps (Heap Dump, System Dump and Java Dump) at Runtime for more detailed analysis. For example, if the Health Center reports increasing heap usage over time and indicates a possible memory leak, you can generate a Heap Dump for further offline analysis.  

Health Center 1.3 now supports enablement of native trace points and the ability to disabling systems selectively to configure data collection to only monitor areas of interest.

An interesting youtube video providing a quick introduction to IBM Health Center: http://www.youtube.com/watch?v=5Tcktcl0qxs

The next couple of blog posts on this subject will cover the steps to install and launching the IBM Health Center and a detailed description of the various subsystems it profiles and provides recommendations on.

---->
...
Class c = findLoadedClass(name);   //Used to check if the class is already loaded
 
if(c == null) {
        try {
            c = super.loadClass(name);  //ask the parent classloader
        } catch (CNFE) {
        }
        if(c == null)
            c = findClass(name); //else load from disk
    }
    return c;
}
<---