1 /*
   2  * Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 
  25 package org.graalvm.compiler.core.test;
  26 
  27 import static java.lang.Boolean.parseBoolean;
  28 import static java.lang.Integer.getInteger;
  29 import static java.lang.System.getProperty;
  30 
  31 import java.io.PrintStream;
  32 import java.lang.reflect.Field;
  33 import java.util.ArrayList;
  34 import java.util.Arrays;
  35 import java.util.Collections;
  36 import java.util.HashMap;
  37 import java.util.List;
  38 import java.util.Map;
  39 
  40 import com.google.monitoring.runtime.instrumentation.AllocationRecorder;
  41 import com.google.monitoring.runtime.instrumentation.Sampler;
  42 
  43 /**
  44  * Tool for analyzing allocations within a scope using the
  45  * <a href="https://code.google.com/p/java-allocation-instrumenter/">Java Allocation
  46  * Instrumenter</a>. Allocation records are aggregated per stack trace at an allocation site. The
  47  * size of the stack trace is governed by the value of the "AllocSpy.ContextSize" system property
  48  * (default is 5).
  49  * <p>
  50  * Using this facility requires using -javaagent on the command line. For example:
  51  *
  52  * <pre>
  53  * mx --vm server unittest -javaagent:lib/java-allocation-instrumenter.jar -dsa -DAllocSpy.ContextSize=6 BC_iadd2
  54  * </pre>
  55  *
  56  * @see #SampleBytes
  57  * @see #SampleInstances
  58  * @see #HistogramLimit
  59  * @see #NameSize
  60  * @see #BarSize
  61  * @see #NumberSize
  62  */
  63 public final class AllocSpy implements AutoCloseable {
  64 
  65     static ThreadLocal<AllocSpy> current = new ThreadLocal<>();
  66 
  67     private static final boolean ENABLED;
  68 
  69     static {
  70         boolean enabled = false;
  71         try {
  72             Field field = AllocationRecorder.class.getDeclaredField("instrumentation");
  73             field.setAccessible(true);
  74             enabled = field.get(null) != null;
  75         } catch (Exception e) {
  76         } catch (LinkageError e) {
  77         }
  78         ENABLED = enabled;
  79         if (ENABLED) {
  80             AllocationRecorder.addSampler(new GraalContextSampler());
  81         }
  82     }
  83 
  84     public static boolean isEnabled() {
  85         return ENABLED;
  86     }
  87 
  88     static String prop(String sfx) {
  89         return AllocSpy.class.getSimpleName() + "." + sfx;
  90     }
  91 
  92     /**
  93      * Determines if bytes per allocation site are recorded.
  94      */
  95     private static final boolean SampleBytes = parseBoolean(getProperty(prop("SampleBytes"), "true"));
  96 
  97     /**
  98      * Determines if allocations per allocation site are recorded.
  99      */
 100     private static final boolean SampleInstances = parseBoolean(getProperty(prop("SampleInstances"), "true"));
 101 
 102     /**
 103      * The size of context to record for each allocation site in terms of Graal frames.
 104      */
 105     private static final int ContextSize = getInteger(prop("ContextSize"), 5);
 106 
 107     /**
 108      * Only the {@code HistogramLimit} most frequent values are printed.
 109      */
 110     private static final int HistogramLimit = getInteger(prop("HistogramLimit"), 40);
 111 
 112     /**
 113      * The width of the allocation context column.
 114      */
 115     private static final int NameSize = getInteger(prop("NameSize"), 50);
 116 
 117     /**
 118      * The width of the histogram bar column.
 119      */
 120     private static final int BarSize = getInteger(prop("BarSize"), 100);
 121 
 122     /**
 123      * The width of the frequency column.
 124      */
 125     private static final int NumberSize = getInteger(prop("NumberSize"), 10);
 126 
 127     final Object name;
 128     final AllocSpy parent;
 129     final Map<String, CountedValue> bytesPerGraalContext = new HashMap<>();
 130     final Map<String, CountedValue> instancesPerGraalContext = new HashMap<>();
 131 
 132     public static AllocSpy open(Object name) {
 133         if (ENABLED) {
 134             return new AllocSpy(name);
 135         }
 136         return null;
 137     }
 138 
 139     private AllocSpy(Object name) {
 140         this.name = name;
 141         parent = current.get();
 142         current.set(this);
 143     }
 144 
 145     @Override
 146     public void close() {
 147         current.set(parent);
 148         PrintStream ps = System.out;
 149         ps.println("\n\nAllocation histograms for " + name);
 150         if (SampleBytes) {
 151             print(ps, bytesPerGraalContext, "BytesPerGraalContext", HistogramLimit, NameSize + 60, BarSize);
 152         }
 153         if (SampleInstances) {
 154             print(ps, instancesPerGraalContext, "InstancesPerGraalContext", HistogramLimit, NameSize + 60, BarSize);
 155         }
 156     }
 157 
 158     private static void printLine(PrintStream printStream, char c, int lineSize) {
 159         char[] charArr = new char[lineSize];
 160         Arrays.fill(charArr, c);
 161         printStream.printf("%s%n", new String(charArr));
 162     }
 163 
 164     private static void print(PrintStream ps, Map<String, CountedValue> map, String name, int limit, int nameSize, int barSize) {
 165         if (map.isEmpty()) {
 166             return;
 167         }
 168 
 169         List<CountedValue> list = new ArrayList<>(map.values());
 170         Collections.sort(list);
 171 
 172         // Sum up the total number of elements.
 173         int total = 0;
 174         for (CountedValue cv : list) {
 175             total += cv.getCount();
 176         }
 177 
 178         // Print header.
 179         ps.printf("%s has %d unique elements and %d total elements:%n", name, list.size(), total);
 180 
 181         int max = list.get(0).getCount();
 182         final int lineSize = nameSize + NumberSize + barSize + 10;
 183         printLine(ps, '-', lineSize);
 184         String formatString = "| %-" + nameSize + "s | %-" + NumberSize + "d | %-" + barSize + "s |\n";
 185         for (int i = 0; i < list.size() && i < limit; ++i) {
 186             CountedValue cv = list.get(i);
 187             int value = cv.getCount();
 188             char[] bar = new char[(int) (((double) value / (double) max) * barSize)];
 189             Arrays.fill(bar, '=');
 190             String[] lines = String.valueOf(cv.getValue()).split("\\n");
 191 
 192             String objectString = lines[0];
 193             if (objectString.length() > nameSize) {
 194                 objectString = objectString.substring(0, nameSize - 3) + "...";
 195             }
 196             ps.printf(formatString, objectString, value, new String(bar));
 197             for (int j = 1; j < lines.length; j++) {
 198                 String line = lines[j];
 199                 if (line.length() > nameSize) {
 200                     line = line.substring(0, nameSize - 3) + "...";
 201                 }
 202                 ps.printf("|   %-" + (nameSize - 2) + "s | %-" + NumberSize + "s | %-" + barSize + "s |%n", line, " ", " ");
 203 
 204             }
 205         }
 206         printLine(ps, '-', lineSize);
 207     }
 208 
 209     CountedValue bytesPerGraalContext(String context) {
 210         return getCounter(context, bytesPerGraalContext);
 211     }
 212 
 213     CountedValue instancesPerGraalContext(String context) {
 214         return getCounter(context, instancesPerGraalContext);
 215     }
 216 
 217     protected static CountedValue getCounter(String desc, Map<String, CountedValue> map) {
 218         CountedValue count = map.get(desc);
 219         if (count == null) {
 220             count = new CountedValue(0, desc);
 221             map.put(desc, count);
 222         }
 223         return count;
 224     }
 225 
 226     private static final String[] Excluded = {AllocSpy.class.getName(), AllocationRecorder.class.getName()};
 227 
 228     private static boolean excludeFrame(String className) {
 229         for (String e : Excluded) {
 230             if (className.startsWith(e)) {
 231                 return true;
 232             }
 233         }
 234         return false;
 235     }
 236 
 237     static class GraalContextSampler implements Sampler {
 238 
 239         @Override
 240         public void sampleAllocation(int count, String desc, Object newObj, long size) {
 241             AllocSpy scope = current.get();
 242             if (scope != null) {
 243                 StringBuilder sb = new StringBuilder(200);
 244                 Throwable t = new Throwable();
 245                 int remainingGraalFrames = ContextSize;
 246                 for (StackTraceElement e : t.getStackTrace()) {
 247                     if (remainingGraalFrames < 0) {
 248                         break;
 249                     }
 250                     String className = e.getClassName();
 251                     boolean isGraalFrame = className.contains(".graal.");
 252                     if (sb.length() != 0) {
 253                         append(sb.append('\n'), e);
 254                     } else {
 255                         if (!excludeFrame(className)) {
 256                             sb.append("type=").append(desc);
 257                             if (count != -1) {
 258                                 sb.append('[').append(count).append(']');
 259                             }
 260                             append(sb.append('\n'), e);
 261                         }
 262                     }
 263                     if (isGraalFrame) {
 264                         remainingGraalFrames--;
 265                     }
 266                 }
 267                 String context = sb.toString();
 268                 if (SampleBytes) {
 269                     scope.bytesPerGraalContext(context).add((int) size);
 270                 }
 271                 if (SampleInstances) {
 272                     scope.instancesPerGraalContext(context).inc();
 273                 }
 274             }
 275         }
 276 
 277         protected StringBuilder append(StringBuilder sb, StackTraceElement e) {
 278             String className = e.getClassName();
 279             int period = className.lastIndexOf('.');
 280             if (period != -1) {
 281                 sb.append(className, period + 1, className.length());
 282             } else {
 283                 sb.append(className);
 284             }
 285             sb.append('.').append(e.getMethodName());
 286             if (e.isNativeMethod()) {
 287                 sb.append("(Native Method)");
 288             } else if (e.getFileName() != null && e.getLineNumber() >= 0) {
 289                 sb.append('(').append(e.getFileName()).append(':').append(e.getLineNumber()).append(")");
 290             } else {
 291                 sb.append("(Unknown Source)");
 292             }
 293             return sb;
 294         }
 295     }
 296 
 297     /**
 298      * A value and a frequency. The ordering imposed by {@link #compareTo(CountedValue)} places
 299      * values with higher frequencies first.
 300      */
 301     static class CountedValue implements Comparable<CountedValue> {
 302 
 303         private int count;
 304         private final Object value;
 305 
 306         CountedValue(int count, Object value) {
 307             this.count = count;
 308             this.value = value;
 309         }
 310 
 311         @Override
 312         public int compareTo(CountedValue o) {
 313             if (count < o.count) {
 314                 return 1;
 315             } else if (count > o.count) {
 316                 return -1;
 317             }
 318             return 0;
 319         }
 320 
 321         @Override
 322         public String toString() {
 323             return count + " -> " + value;
 324         }
 325 
 326         public void inc() {
 327             count++;
 328         }
 329 
 330         public void add(int n) {
 331             count += n;
 332         }
 333 
 334         public int getCount() {
 335             return count;
 336         }
 337 
 338         public Object getValue() {
 339             return value;
 340         }
 341     }
 342 }