[OpenJDK 2D-Dev] Review Request for 6879044

[Mandy Chung]

Hi Andrew,

 > Why not just use a straightforward static assignment to a final
 > variable as before?

A simple AWT app creates 79 loggers on solaris-i586 and 34 loggers on 
windows-i586.  SwingSet2 creates a total of 85 loggers on solaris-i586 
and 35 on windows-i586.

Improvement on client startup performance and memory footprint has 
always been one of our top features in the past releases.

As I noted in CR 6880089 (Revisit the number of AWT loggers to reduce 
the memory usage), there is no strong reason why we need such 
fine-grained loggers.

I fixed AWTEvent since it's one obvious candidate for lazy 
initialization. With my fix, I reduced the number of loggers by 4.  Alex 
Potochkin also brought up a consistency issue that will be addressed by 
6880089 or a new CR.

 > Is it really that unlikely that fine() will be
 > called that we need not initialise this early?

AWT team, can you confirm?

 > At the very least consider using the lazy holder idiom over volatile.

Good point.
Mandy

Andrew John Hughes wrote:
> 2009/9/14 Mandy Chung <Mandy.Chung at sun.com>:
>
> I'm curious as to why some of the initialisations are lazy and some
> are eager.  Notably AWTEvent is changed from eager to lazy:
> 
>  public abstract class AWTEvent extends EventObject {
> -    private static final Logger log = Logger.getLogger("java.awt.AWTEvent");
> +    private static volatile PlatformLogger log;
> +
> ...
> +
> +    // log fine message to the java.awt.AWTEvent logger
> +    private static void fine(String msg, Throwable t) {
> +        if (log == null) {
> +            log = PlatformLogger.getLogger("java.awt.AWTEvent");
> +        }
> +        if (log.isLoggable(PlatformLogger.FINE)) {
> +            log.fine(msg, t);
> +        }
> +    }
> +
> 
> 
> Although the use of volatile should ensure the correct ordering of
> operations, there is still the possibility of a minor race here as the
> if condition and its body are not atomic; thus there could be multiple
> calls to PlatformLogger.getLogger should a thread be interrupted
> between the check and the assignment.
> 
> Why not just use a straightforward static assignment to a final
> variable as before?  Is it really that unlikely that fine() will be
> called that we need not initialise this early?.  At the very least
> consider using the lazy holder idiom over volatile.