Mahadevan Gorti SS

When you applied -server flag for JVM, did you run the benchmark for some warmup time --so that JVM can findout hotspots properly and do necessary optimizations

Here another approach with RE. You have to test it thoroughly
import java.io.FileInputStream; import java.nio.CharBuffer; import java.nio.MappedByteBuffer; import java.nio.channels.FileChannel; import java.nio.charset.Charset; import java.nio.charset.CharsetDecoder; import java.util.regex.Matcher; import java.util.regex.Pattern; /** * @author mahadevan */ public class REKindColorMatcher { public static final String CRLF=System.getProperty("line.separator"); public static final String RE_CRLF="\r?\n"; public static final String FILE=System.getProperty("FILE","F:/vob/test/data.txt"); // Charset and decoder for ISO-8859-15 private static Charset charset = Charset.forName("ISO-8859-15"); private static CharsetDecoder decoder = charset.newDecoder(); /** * @param args */ public static void main(String[] args) { System.out.println("Usage: java [-DFILE="+FILE+"] REKindColorMatcher kind color"); if(args.length < 2){ System.exit(-1); } String kind=args[0]; String color=args[1]; String REQ_RE = "Kind:"+kind+RE_CRLF+"Name:.*"+RE_CRLF+"Weight:.*"+RE_CRLF+ "Color:"+color+RE_CRLF+"Garbage:.*"+RE_CRLF; String START_RE = "Kind:"+kind+RE_CRLF+".*"+RE_CRLF+".*"+RE_CRLF+".*"+RE_CRLF+".*"+RE_CRLF; search(REQ_RE, START_RE); } private static void search(String REQ_RE, String START_RE) { try { Pattern pat = Pattern.compile(START_RE);//,Pattern.MULTILINE); Pattern reqPat = Pattern.compile(REQ_RE);//,Pattern.MULTILINE); ///System.out.println("Pattern is:"+pat.pattern()); //Open the file and then get a channel from the stream FileInputStream fis = new FileInputStream(FILE); FileChannel fc = fis.getChannel(); // Get the file's size and then map it into memory, trake care for very-very large //files ( size greater than 10 MB,etc TODO) int sz = (int)fc.size(); MappedByteBuffer bb = fc.map(FileChannel.MapMode.READ_ONLY, 0, sz); // Decode the file into a char buffer CharBuffer cb = decoder.decode(bb); Matcher startMat = pat.matcher(cb); //System.out.println(cb+CRLF+CRLF); int lines=0; while(startMat.find()){ lines++; CharSequence cs = startMat.group(); //System.out.println(lines+"==>"+CRLF+cs+CRLF+CRLF); Matcher reqMat = reqPat.matcher(cs); if(reqMat.matches()){ CharSequence reqCs = reqMat.group(); System.out.println(CRLF+"========= "+lines+"===========@"+startMat.start()+CRLF+reqCs); } if(startMat.end() == cb.limit()){ break; } } } catch (Exception e) { e.printStackTrace(); } } } /* Contents of F:/vob/test/data.txt * Run like java -DFILE=F:/vob/test/data.txt REKindColorMatcher Screwdriver Silver Kind:Screwdriver Name:Screwdrive Weight:5 Color:Silver Garbage:No Kind:hammer Name:hamme Weight:7 Color:brown Garbage:No Kind:Screwdriver Name:Screwdrive Weight:50 Color:Silver Garbage:Yes Kind:Screwdriverq Name:Screwdriveqq Weight:5 Color:Silverq Garbage:No Kind:Screwdfdfdriver Name:Screwdrive Weight:5 Color:qSilver Garbage:No Kind:Screwdriver Name:Screwdrive Weight:501 Color:Silver Garbage:No Kind:Screwdriver Name:Screwdrive Weight:51 Color:Silver Garbage:No */

Output for above program for input from f:/vob/test/data.txt is:
Usage: java [-DFILE=F:/vob/test/data.txt] REKindColorMatcher kind color

========= 1===========@0
Kind:Screwdriver
Name:Screwdrive
Weight:5
Color:Silver
Garbage:No


========= 2===========@131
Kind:Screwdriver
Name:Screwdrive
Weight:50
Color:Silver
Garbage:Yes


========= 3===========@355
Kind:Screwdriver
Name:Screwdrive
Weight:501
Color:Silver
Garbage:No


========= 4===========@428
Kind:Screwdriver
Name:Screwdrive
Weight:51
Color:Silver
Garbage:No
[ March 30, 2006: Message edited by: Mahadevan Gorti SS ]

Ajay,

Would you please give more details like(or check for your self) :
* What is the packet rate your are sending and receving
* What is the max/min/avg size of packets(UDP)?
* At what rate you started loosing packets
* What is system load
* What is Network interfaces capacity (in Mbytes/sec) for server/client machines
* What OS. Is server/client are in WAN type of setup
* Would it be possible to give breif snippet of your receiver's code.
* What is load of OS when you are running this programme
* What is the Logger you are using -- if load is causing problems
* What is the value for DatagramSocket: getReceiveBufferSize()
* What is the Thread priority for receiving the UDP packets
* Are the receiving packets recieved as fragmented(check via ethereal)


BTW, I was able to recieve UDP packets of sizes upto 1500(MTU of network interface) till 1500 packets/sec without loosing in java(that too 1.3.1) in java(with out use of JDK NIO) on PIII with 533 MHz and 256 MB RAM. I have not tried for packet-rates above 1500

As we have already covered all cases about Iterator/Enum/get cases, here are some additional points.

Here is a practical case where you would prefer a get from a Vector/AttayList over Iterator/Enumeration:
* Handling some tight loop of code where one has to process events more than 100/sec(for example). In each event loop, if one has to go thru the for-loop/Iterator(and the underlying data-structure is Vector/ArrayList/etc), for-loop is preferable for reason
-- It is faster than Iterator
-- It creates less garbage(so is the GC CPU utilization)

I think you should use JDK 1.4 regular expression(RE) for doing that sort of search. Sun has NIO examples at http://java.sun.com/j2se/1.4.2/docs/guide/nio/example/Grep.java.

OR you can use RE for you code like:
Pattern pat = Pattern.compile("^"+kind+":"+color+"$"); while((kindcheck = br1.readLine()) != null){ kindcheck.trim();// to strip while spaces Matcher mat = pat.matcher(kindcheck); if(mat.matches(){ // print macthed .... } }

For a cases where you know the conditions is met -- some boolean condition made true/false some where else in program (with a different thread of execution), you can follow Stan's method of breaking out of loop. I think your case is mostly of CPU consuming task(with no blocking calls in code).

But there are cases, where you are blocked in JVM in following cases:
* Thread.sleep(x)
* Object.wait()
* Some OS specific blocking calls like IO, network sockets,etc.

In these cases, even if one detect a boolean condition, one cannot come out of the loop -- as calling thread is blocked.

One way out for such conditons is:
* Put the code for the long-time-consuming job in Runnable.run method
* Give this job to a Thread-Pool with a timeout parameter. Note down the Thread which is doing the job
* If thread pool does not support timeout of a task, write your timeout handler something like:
* Run a separate Timer task to monitor time for each long-task that has been submitted and after timeout
* Interrupt the blocked thread with proper checks

Hope this helps

First for getting OS,OS-Version, Architecyure, JVM version, JVM vendor, use System.getProperties().

For getting physical memory info and processor extra details use OS specific
program and run that program via (Runtime.exec) and parse and get the required lines. Here are some commands that would be of use to you.



For windows NT(Also see 'typeperf' command, specified elsewhere in this forum)
F:\opt\bin>psinfo PsInfo v1.73 - Local and remote system information viewer Copyright (C) 2001-2005 Mark Russinovich Sysinternals - <a href="http://www.sysinternals.com" target="_blank" rel="nofollow">www.sysinternals.com</a> System information for \\KRISHNA: Uptime: 0 days 1 hour 37 minutes 4 seconds Kernel version: Microsoft Windows XP, Multiprocessor Free Product type: Professional Product version: 5.1 Service pack: 2 Kernel build number: 2600 Registered organization: self Registered owner: Mahadevan Install date: 3/4/2006, 12:27:24 PM Activation status: Error reading status IE version: 6.0000 System root: C:\WINDOWS Processors: 2 Processor speed: 3.0 GHz Processor type: Mobile Intel(R) Pentium(R) 4 CPU Physical memory: 512 MB Video driver: NVIDIA GeForce FX Go5200

For general Unix stuff
uname -a

For solaris(for getting processort info, phy. memory,etc).
prtconf (gives phy. mem.) psrinfo -v isainfo

For Linux for getting Physical/swap memory)
free Also see /proc directory for extra info

Stu,
Hope this link will take care of all possible future cases & conbinations

http://pierre-luc.paour.9online.fr/NaturalOrderComparator.java

You can try Regular expression (if your JDK > 1.4) like:

import java.util.regex.Matcher; import java.util.regex.Pattern; public class NameValidator { static final Pattern[] patterns = new Pattern[2]; public static final int SURNAME=0; public static final int NAME=1; static{ patterns[SURNAME]=Pattern.compile("^[a-zA-Z]*"); patterns[NAME]=Pattern.compile("^[a-zA-Z, \\.]*"); } /** * @param args */ public static void main(String[] args) { String[] names = {"Mr. ABC xyz","Jr. Wallace","XyzPqr","x2 is bad"}; String[] surNames = {"vander val","gorti"}; System.out.println("Names testing:"); for(int i=0;i<names.length;i++){ String nm=names[i]; System.out.println(nm+"-->"+validate(NAME, nm)); } System.out.println("\n\nSurnames testing"); for(int i=0;i<surNames.length;i++){ String nm=surNames[i]; System.out.println(nm+"-->"+validate(NAME, nm)); } } public static boolean validate(int type,String name){ Pattern pat=null; switch(type){ case SURNAME : pat=patterns[SURNAME];break; case NAME : pat=patterns[NAME];break; default:// write error } if(pat == null){ // write error return false; } Matcher matcher=pat.matcher(name); return matcher.matches(); } }

[ March 26, 2006: Message edited by: Mahadevan Gorti SS ]
[ March 27, 2006: Message edited by: Mahadevan Gorti SS ]

Try running ethereal(network packet captuerer from http://www.ethereal.com/ ) on both server and client and try to start transaction and see for packets traversed between server/client

Apart from 'typeperf' -- which is not available in other Windows versions(one has to download from web with possible non-working version of typeperf.exe in another windows version), one can use 'pslist.exe' from http://www.sysinternals.com. pslist.exe is available in http://www.sysinternals.com/Utilities/PsTools.html.

pslist will also be useful for one to see which thread is taking more time(OR doing tight loops in a JVM).


If you JDK 1.5 onwards, pure java code without resorting to Runtime.exec ( which is costly) using JMX package java.lang.management. The JMX-bean/classes you are interested are:
* ThreadInfo
* ThreadMBean
[ March 24, 2006: Message edited by: Mahadevan Gorti SS ]

Originally posted by Ernest Friedman-Hill:
You're describing a sort of degenerate "Abstract Factory" pattern; usually the factory class (the one with the "create" method) is a separate class from the product class (the one that is created.) See here for more of a description.

As I said earlier, you can use clone if you can.

Definetely I used "Abstract Factory" pattern, but it is not a degenrate case . Even in ""Abstract Factory" pattern case, how one can generate classes in runtime with these conditions these may depends on restrictions on practical situation that arised in my case)

One cannot use Reflection -- for performace reasons

One cannot implement Cloneable interface in the class heirarchy( the said base/some-sub classes cannot implement Cloneable interface)

Similiar code/pattern should be used in corresponding C/C++ code(that complements java code)

Use of switch case in "Abstract Factory" implementation is prohibited -- for obvious reasons of long term maintainance issues

Use of if-else-statements in "Abstract Factory" implementation is prohibited -- for obvious reasons of long term maintainance issues

So tell me if you have any other method/way/suggestion to do same thing in "Abstract Factory" with above conditions.

As rightly said above, unless you have some important/compelling reason to avoid synchronization-lock, there is no need for one to see for other altrenatives.

If you want multiple threads to access a shared resource without sync-lock, you can see Doug Lea's Concurrent HashMap(now in JDK 1.5). You can use similair strategy for your code.

If Still you wanted to go ahead, you can see JDK 1.5 package ' java.util.concurrent.atomic' -- for AtomBoolean, AtomicIntger, AtomicLong for customization for your code(these can be used my mutiple threads to have detectionb mechanism for entring/doing something in a method). But beaware, the methods in those atomic-xlasses might involve tight spinloop(if the other thread takes much time to complete). Also these classes do have native methods -- ofcourse written by Sun , in platform independent way.

Apart from normal use of clone as specified Sun and Others, one can use clone innovatively for creating classes in runtime without reflection,etc.

This can be really useful for a case of Classes(various strategies) -- which are derived from a common base class, to be executed for different conditions(strategies)

As sun's clone is too-many if's-but's(for good cause/safety), I have implemented my-own close with an hierarchy of classes which do use creative use of clone. I named my method to create(instead of clone and to stop its unwanted checks/restrictions in my code). I not here saying clone can't be used in my case -- what I am suggesting is another way using clone in practical applications.


So concept is like this:

Have a parent class have an abstract methods in Base-class with create method and some doJob/run,preJob/postJob methods for doing real work

Let is child class implement the create method which will do a new of that child class . Also child class implements some get/set methods and doJob/run for doinf real-work.

When JVM has started , register of all child classes in static Map with public methods to get an instance of that class(with a key of string/integer/some-key) . This could be also from a property file with class-names versus some string/integer/some-key

In a class where we need to create different child class for different strategy, get the instance of child-class by passing appropriate key.

Now create appropriate child class by calling create method. Do any pre processing in that child class instance by using preJob. Then call doJob/doJob/run. After the that call postJob.

By use in this way one can add more strategies or handlers(without using Reflection/switch case statements).


Same methodolgy can applied on other languages -- C,C++,etc

Here some steps to tacke the issue of high Cyclomatic Complexity Number(CCN):

* Generalize the code/methods
* Read Martin Fowlers' Refactoring book -- this contains lots of ideas
* Most of the developers has an idea/concept that adding more methods will reduce the performance and write big methods with lots of if/else, indentation,etc --which finally leads to high CCN. But performance wise, most of the performant code is concetrated only in 20% of whole code base(80-20 rule).So one has to see, is this method(that is having high CCN) is really performance critical code-path. If not,then break that method to small methods to generalize.

* Introduce the checks in organization's build process to STOP inserting the code with high CCN in to production loads( this process may have some exception cases for old code and new code based on need/etc. But these exceptions need to be ratified by discussion).
* Use Checkstyle in ANT build files to give feedback/warning on CCN numbers
* Use Checkstyle in ANT build files to give feedback/warning on large method NCSL(non commented source lines)
* Use Checkstyle in ANT build files to give feedback/warning on deep indentation in code base
* Educate the Developers about CCN. Let them know/use JavaNCSS package for getting the CCN numbers
* Educate the Developers about OOP(for new/old/extension design/coding) for reusability am=nd maintainable code
* Educate the Developers about the Refactoring(Martin Fowlers book read is a MUST). Also let them use Eclipse/other-famous-IDE's refactoring tools for reducing the CCN/etc