@Override
  public void query(QueryContext context, String queryString, MetadataCallback callback) {
    ThreadMXBean bean = ManagementFactory.getThreadMXBean();

    ArrayList<ThreadCpuUsage> usages = new ArrayList<ThreadCpuUsage>();

    for (long tid : bean.getAllThreadIds()) {
      long time = bean.getThreadCpuTime(tid);
      usages.add(new ThreadCpuUsage(tid, time));
    }

    try {
      Thread.sleep(1000);
    } catch (InterruptedException e) {
    }

    Map<Thread, StackTraceElement[]> stacks = Thread.getAllStackTraces();

    for (long tid : bean.getAllThreadIds()) {
      ThreadCpuUsage usage = find(usages, tid);
      if (usage != null) usage.secondTime = bean.getThreadCpuTime(tid);
    }

    Collections.sort(usages);

    for (ThreadCpuUsage usage : usages) {
      long elapsed = usage.secondTime - usage.firstTime;
      // remove just created thread or sleeping threads (noisy)
      if (elapsed <= 0) continue;

      StringBuilder sb = new StringBuilder();
      Thread t = findThread(stacks, usage.tid);
      if (t == null) continue;

      StackTraceElement[] stack = findStack(stacks, usage.tid);
      for (StackTraceElement el : stack) {
        sb.append(
            String.format(
                "%s.%s %s\n", el.getClassName(), el.getMethodName(), getFileAndLineNumber(el)));
      }

      Map<String, Object> m = new HashMap<String, Object>();
      m.put("tid", t.getId());
      m.put("name", t.getName());
      m.put("state", t.getState().toString());
      m.put("priority", t.getPriority());
      m.put("usage", elapsed);
      m.put("stacktrace", sb.toString());

      callback.onPush(new Row(m));
    }
  }
  /**
   * Update the information about completed thread that ran for runtime in milliseconds
   *
   * <p>This method updates all of the key timing and tracking information in the factory so that
   * thread can be retired. After this call the factory shouldn't have a pointer to the thread any
   * longer
   *
   * @param thread the thread whose information we are updating
   */
  @Ensures({"getTotalTime() >= old(getTotalTime())"})
  public synchronized void threadIsDone(final Thread thread) {
    nThreadsAnalyzed++;

    if (DEBUG) logger.warn("UpdateThreadInfo called");

    final long threadID = thread.getId();
    final ThreadInfo info = bean.getThreadInfo(thread.getId());
    final long totalTimeNano = bean.getThreadCpuTime(threadID);
    final long userTimeNano = bean.getThreadUserTime(threadID);
    final long systemTimeNano = totalTimeNano - userTimeNano;
    final long userTimeInMilliseconds = nanoToMilli(userTimeNano);
    final long systemTimeInMilliseconds = nanoToMilli(systemTimeNano);

    if (info != null) {
      if (DEBUG)
        logger.warn(
            "Updating thread with user runtime "
                + userTimeInMilliseconds
                + " and system runtime "
                + systemTimeInMilliseconds
                + " of which blocked "
                + info.getBlockedTime()
                + " and waiting "
                + info.getWaitedTime());
      incTimes(State.BLOCKING, info.getBlockedTime());
      incTimes(State.WAITING, info.getWaitedTime());
      incTimes(State.USER_CPU, userTimeInMilliseconds);
      incTimes(State.WAITING_FOR_IO, systemTimeInMilliseconds);
    }
  }
  public boolean search() {

    Thread tread = java.lang.Thread.currentThread();
    java.lang.management.ThreadMXBean b = java.lang.management.ManagementFactory.getThreadMXBean();

    long startCPU = b.getThreadCpuTime(tread.getId());
    long startUser = b.getThreadUserTime(tread.getId());

    boolean result = store.consistency();
    System.out.println("*** consistency = " + result);

    Search<SetVar> label = new DepthFirstSearch<SetVar>();

    SelectChoicePoint<SetVar> select =
        new SimpleSelect<SetVar>(
            vars.toArray(new SetVar[vars.size()]),
            new MinLubCard<SetVar>(),
            new MaxGlbCard<SetVar>(),
            new IndomainSetMin<SetVar>());

    //	label.setSolutionListener(new SetSimpleSolutionListener<SetVar>());
    label.getSolutionListener().searchAll(false);
    label.getSolutionListener().recordSolutions(false);

    result = label.labeling(store, select);

    if (result) {
      System.out.println("*** Yes");
      for (int i = 0; i < weeks; i++) {
        for (int j = 0; j < groups; j++) {
          System.out.print(golferGroup[i][j].dom() + " ");
        }
        System.out.println();
      }
    } else System.out.println("*** No");

    System.out.println(
        "ThreadCpuTime = " + (b.getThreadCpuTime(tread.getId()) - startCPU) / (long) 1e+6 + "ms");
    System.out.println(
        "ThreadUserTime = "
            + (b.getThreadUserTime(tread.getId()) - startUser) / (long) 1e+6
            + "ms");

    return result;
  }
Example #4
0
  /**
   * It parses the provided file and parsing parameters followed by problem solving.
   *
   * @param args parameters describing the flatzinc file containing the problem to be solved as well
   *     as options for problem solving.
   *     <p>TODO what are the conditions for different exceptions being thrown? Write little info
   *     below.
   * @throws ParseException
   * @throws TokenMgrError
   */
  public static void main(String[] args) {

    Options opt = new Options(args);

    if (opt.getVerbose())
      System.out.println("Flatzinc2JaCoP: compiling and executing " + args[args.length - 1]);

    Thread tread = java.lang.Thread.currentThread();
    java.lang.management.ThreadMXBean b = java.lang.management.ManagementFactory.getThreadMXBean();
    long startCPU = b.getThreadCpuTime(tread.getId());

    Parser parser = new Parser(opt.getFile());
    parser.setOptions(opt);

    try {

      parser.model();

    } catch (FailException e) {
      System.err.println(
          "=====UNSATISFIABLE====="); // "*** Evaluation of model resulted in fail.");
    } catch (ArithmeticException e) {
      System.err.println("*** Evaluation of model resulted in integer overflow.");
    } catch (ParseException e) {
      System.out.println("*** Parser exception " + e);
    } catch (TokenMgrError e) {
      System.out.println("*** Parser exception " + e);
    } catch (ArrayIndexOutOfBoundsException e) {
      System.out.println("*** Array out of bound exception " + e);
    } catch (OutOfMemoryError e) {
      System.out.println("*** Out of memory error; consider option -Xmx... for JVM");
    } catch (StackOverflowError e) {
      System.out.println("*** Stack overflow exception error; consider option -Xss... for JVM");
    }

    if (opt.getStatistics()) {
      System.out.println(
          "\nTotal CPU time : "
              + (b.getThreadCpuTime(tread.getId()) - startCPU) / (long) 1e+6
              + "ms");
    }
  }
    @DwrPermission(admin = true)
    public ProcessResult getThreadInfo() {
      synchronized (threadInfos) {
        ProcessResult result = new ProcessResult();

        // All of the last thread ids. Ids are removed from this set as they are processed. If ids
        // remain,
        // it means the thread is gone and should be removed from the map.
        Set<Long> threadIds = new HashSet<>(threadInfos.keySet());

        ThreadInfo[] threads = tmxb.getThreadInfo(tmxb.getAllThreadIds(), Integer.MAX_VALUE);
        List<ThreadInfoBean> beans = new ArrayList<>();
        for (ThreadInfo thread : threads) {
          if (thread == null) continue;

          ThreadInfoBean bean = threadInfos.get(thread.getThreadId());
          if (bean == null) {
            bean = new ThreadInfoBean();
            bean.setId(thread.getThreadId());
            bean.setName(thread.getThreadName());
            threadInfos.put(bean.getId(), bean);
          } else threadIds.remove(bean.getId());

          bean.setCpuTime(tmxb.getThreadCpuTime(bean.getId()));
          bean.setState(thread.getThreadState().name());

          if (thread.getThreadState() == State.BLOCKED)
            bean.setState(
                bean.getState()
                    + " by '"
                    + thread.getLockOwnerName()
                    + "' ("
                    + thread.getLockOwnerId()
                    + ")");

          bean.setStackTrace(thread.getStackTrace());

          beans.add(bean);
        }

        // Remove unreferenced threads
        for (Long id : threadIds) threadInfos.remove(id);

        result.addData("threads", beans);

        return result;
      }
    }
Example #6
0
  /**
   * Formats the thread dump header for one thread.
   *
   * @param ti the ThreadInfo describing the thread
   * @return the formatted thread dump header
   */
  private static String getThreadDumpHeader(ThreadInfo ti) {
    StringBuilder sb = new StringBuilder("\"" + ti.getThreadName() + "\"");
    sb.append(" Id=" + ti.getThreadId());
    sb.append(" cpu=" + threadMXBean.getThreadCpuTime(ti.getThreadId()) + " ns");
    sb.append(" usr="******" ns");
    sb.append(" blocked " + ti.getBlockedCount() + " for " + ti.getBlockedTime() + " ms");
    sb.append(" waited " + ti.getWaitedCount() + " for " + ti.getWaitedTime() + " ms");

    if (ti.isSuspended()) {
      sb.append(" (suspended)");
    }
    if (ti.isInNative()) {
      sb.append(" (running in native)");
    }
    sb.append(CRLF);
    sb.append(INDENT3 + "java.lang.Thread.State: " + ti.getThreadState());
    sb.append(CRLF);
    return sb.toString();
  }
Example #7
0
  @RequestMapping("/loadThreadInfo")
  @ResponseBody
  public JSONObject doLoadThreadInfo(HttpServletRequest request) {
    try {
      String app = request.getParameter("app");
      ThreadMXBean tBean = JMConnManager.getThreadMBean(app);
      ThreadInfo[] allThreads = tBean.dumpAllThreads(false, false);

      JSONObject root = new JSONObject();
      JSONArray detail = new JSONArray();
      HashMap<State, Integer> state = new HashMap<Thread.State, Integer>();
      for (ThreadInfo info : allThreads) {
        JSONObject th = new JSONObject();
        long threadId = info.getThreadId();
        long cpu = tBean.getThreadCpuTime(threadId);
        State tState = info.getThreadState();

        th.put("id", threadId);
        th.put("state", tState);
        th.put("name", info.getThreadName());
        th.put("cpu", TimeUnit.NANOSECONDS.toMillis(cpu));
        detail.add(th);

        Integer vl = state.get(tState);
        if (vl == null) {
          state.put(tState, 0);
        } else {
          state.put(tState, vl + 1);
        }
      }

      root.put("state", state);
      root.put("detail", detail);
      root.put("total", tBean.getThreadCount());
      root.put("time", System.currentTimeMillis());
      root.put("deamon", tBean.getDaemonThreadCount());

      return root;
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }
  protected String generateThreadDump() {
    StringBuilder dump = new StringBuilder();
    ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
    ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(true, true);
    long currentThreadId = Thread.currentThread().getId();
    for (ThreadInfo threadInfo : threadInfos) {
      long threadId = threadInfo.getThreadId();
      if (threadId == currentThreadId) {
        continue;
      }
      dump.append('"');
      dump.append(threadInfo.getThreadName());
      dump.append("\" ");

      Thread.State state = threadInfo.getThreadState();
      dump.append("\n\tjava.lang.Thread.State: ");
      dump.append(state);
      if (threadInfo.getLockName() != null) {
        dump.append(", on lock=").append(threadInfo.getLockName());
      }
      if (threadInfo.getLockOwnerName() != null) {
        dump.append(", owned by ").append(threadInfo.getLockOwnerName());
        dump.append(", id=").append(threadInfo.getLockOwnerId());
      }
      if (THREAD_CPU_TIME_INFO_AVAILABLE) {
        dump.append(", cpu=").append(threadMXBean.getThreadCpuTime(threadId)).append(" nsecs");
        dump.append(", usr="******" nsecs");
      }
      if (THREAD_CONTENTION_INFO_AVAILABLE) {
        dump.append(", blocked=").append(threadInfo.getBlockedTime()).append(" msecs");
        dump.append(", waited=").append(threadInfo.getWaitedTime()).append(" msecs");
      }
      StackTraceElement[] stackTraceElements = threadInfo.getStackTrace();
      for (StackTraceElement stackTraceElement : stackTraceElements) {
        dump.append("\n\t\tat ");
        dump.append(stackTraceElement);
      }
      dump.append("\n\n");
    }
    return dump.toString();
  }
Example #9
0
  /**
   * Return current (raw) list of thread info objects wrapped in ThreadRankInfo type.
   *
   * @return list of threads
   */
  protected List<ThreadRankInfo> rawList() {
    // Platform MBean Server startup might be suspended (eg. for JBoss AS);
    if (threadMXBean == null) {
      if (mBeanServerRegistry.lookup("java") != null) {
        threadMXBean = ManagementFactory.getThreadMXBean();
      } else {
        return new ArrayList<ThreadRankInfo>(1);
      }
    }

    ThreadInfo[] ati = threadMXBean.getThreadInfo(threadMXBean.getAllThreadIds());
    List<ThreadRankInfo> lst = new ArrayList<ThreadRankInfo>(ati.length);

    for (ThreadInfo ti : ati) {
      long tid = ti.getThreadId();
      long cpuTime = threadMXBean.getThreadCpuTime(tid);
      lst.add(new ThreadRankInfo(tid, ti.getThreadName(), cpuTime, ti.getBlockedTime()));
    }

    return lst;
  }
Example #10
0
  private static SimpleOrderedMap<Object> getThreadInfo(ThreadInfo ti, ThreadMXBean tmbean) {
    SimpleOrderedMap<Object> info = new SimpleOrderedMap<Object>();
    long tid = ti.getThreadId();

    info.add("id", tid);
    info.add("name", ti.getThreadName());
    info.add("state", ti.getThreadState().toString());

    if (ti.getLockName() != null) {
      info.add("lock", ti.getLockName());
    }
    if (ti.isSuspended()) {
      info.add("suspended", true);
    }
    if (ti.isInNative()) {
      info.add("native", true);
    }

    if (tmbean.isThreadCpuTimeSupported()) {
      info.add("cpuTime", formatNanos(tmbean.getThreadCpuTime(tid)));
      info.add("userTime", formatNanos(tmbean.getThreadUserTime(tid)));
    }

    if (ti.getLockOwnerName() != null) {
      SimpleOrderedMap<Object> owner = new SimpleOrderedMap<Object>();
      owner.add("name", ti.getLockOwnerName());
      owner.add("id", ti.getLockOwnerId());
    }

    // Add the stack trace
    int i = 0;
    String[] trace = new String[ti.getStackTrace().length];
    for (StackTraceElement ste : ti.getStackTrace()) {
      trace[i++] = ste.toString();
    }
    info.add("stackTrace", trace);
    return info;
  }
Example #11
0
 /**
  * @param thread
  * @return cpu time for the given thread in seconds, <code>-1</code> if cpu time is not measured.
  */
 public static final double getThreadCpuTime(final Thread thread) {
   if (tbe.isThreadCpuTimeEnabled()) {
     return tbe.getThreadCpuTime(thread.getId()) / 1.0e9;
   }
   return -1;
 }
Example #12
0
 public static long getThreadTime(long tid) {
   ThreadMXBean tb = ManagementFactory.getThreadMXBean();
   return tb.getThreadCpuTime(tid);
 }
Example #13
0
  private String innerDetect() throws Exception {
    StringBuilder sb = new StringBuilder();

    sb.append("Hot threads at ");
    sb.append(DATE_TIME_FORMATTER.printer().print(System.currentTimeMillis()));
    sb.append(", interval=");
    sb.append(interval);
    sb.append(", busiestThreads=");
    sb.append(busiestThreads);
    sb.append(", ignoreIdleThreads=");
    sb.append(ignoreIdleThreads);
    sb.append(":\n");

    ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
    boolean enabledCpu = false;
    try {
      if (threadBean.isThreadCpuTimeSupported()) {
        if (!threadBean.isThreadCpuTimeEnabled()) {
          enabledCpu = true;
          threadBean.setThreadCpuTimeEnabled(true);
        }
      } else {
        throw new IllegalStateException("MBean doesn't support thread CPU Time");
      }
      Map<Long, MyThreadInfo> threadInfos = new HashMap<>();
      for (long threadId : threadBean.getAllThreadIds()) {
        // ignore our own thread...
        if (Thread.currentThread().getId() == threadId) {
          continue;
        }
        long cpu = threadBean.getThreadCpuTime(threadId);
        if (cpu == -1) {
          continue;
        }
        ThreadInfo info = threadBean.getThreadInfo(threadId, 0);
        if (info == null) {
          continue;
        }
        threadInfos.put(threadId, new MyThreadInfo(cpu, info));
      }
      Thread.sleep(interval.millis());
      for (long threadId : threadBean.getAllThreadIds()) {
        // ignore our own thread...
        if (Thread.currentThread().getId() == threadId) {
          continue;
        }
        long cpu = threadBean.getThreadCpuTime(threadId);
        if (cpu == -1) {
          threadInfos.remove(threadId);
          continue;
        }
        ThreadInfo info = threadBean.getThreadInfo(threadId, 0);
        if (info == null) {
          threadInfos.remove(threadId);
          continue;
        }
        MyThreadInfo data = threadInfos.get(threadId);
        if (data != null) {
          data.setDelta(cpu, info);
        } else {
          threadInfos.remove(threadId);
        }
      }
      // sort by delta CPU time on thread.
      List<MyThreadInfo> hotties = new ArrayList<>(threadInfos.values());
      final int busiestThreads = Math.min(this.busiestThreads, hotties.size());
      // skip that for now
      CollectionUtil.introSort(
          hotties,
          new Comparator<MyThreadInfo>() {
            @Override
            public int compare(MyThreadInfo o1, MyThreadInfo o2) {
              if ("cpu".equals(type)) {
                return (int) (o2.cpuTime - o1.cpuTime);
              } else if ("wait".equals(type)) {
                return (int) (o2.waitedTime - o1.waitedTime);
              } else if ("block".equals(type)) {
                return (int) (o2.blockedTime - o1.blockedTime);
              }
              throw new IllegalArgumentException();
            }
          });
      // analyse N stack traces for M busiest threads
      long[] ids = new long[busiestThreads];
      for (int i = 0; i < busiestThreads; i++) {
        MyThreadInfo info = hotties.get(i);
        ids[i] = info.info.getThreadId();
      }
      ThreadInfo[][] allInfos = new ThreadInfo[threadElementsSnapshotCount][];
      for (int j = 0; j < threadElementsSnapshotCount; j++) {
        // NOTE, javadoc of getThreadInfo says: If a thread of the given ID is not alive or does not
        // exist,
        // null will be set in the corresponding element in the returned array. A thread is alive if
        // it has
        // been started and has not yet died.
        allInfos[j] = threadBean.getThreadInfo(ids, Integer.MAX_VALUE);
        Thread.sleep(threadElementsSnapshotDelay.millis());
      }
      for (int t = 0; t < busiestThreads; t++) {
        long time = 0;
        if ("cpu".equals(type)) {
          time = hotties.get(t).cpuTime;
        } else if ("wait".equals(type)) {
          time = hotties.get(t).waitedTime;
        } else if ("block".equals(type)) {
          time = hotties.get(t).blockedTime;
        }
        String threadName = null;
        for (ThreadInfo[] info : allInfos) {
          if (info != null && info[t] != null) {
            if (ignoreIdleThreads && isIdleThread(info[t])) {
              info[t] = null;
              continue;
            }
            threadName = info[t].getThreadName();
            break;
          }
        }
        if (threadName == null) {
          continue; // thread is not alive yet or died before the first snapshot - ignore it!
        }
        double percent = (((double) time) / interval.nanos()) * 100;
        sb.append(
            String.format(
                Locale.ROOT,
                "%n%4.1f%% (%s out of %s) %s usage by thread '%s'%n",
                percent,
                TimeValue.timeValueNanos(time),
                interval,
                type,
                threadName));
        // for each snapshot (2nd array index) find later snapshot for same thread with max number
        // of
        // identical StackTraceElements (starting from end of each)
        boolean[] done = new boolean[threadElementsSnapshotCount];
        for (int i = 0; i < threadElementsSnapshotCount; i++) {
          if (done[i]) continue;
          int maxSim = 1;
          boolean[] similars = new boolean[threadElementsSnapshotCount];
          for (int j = i + 1; j < threadElementsSnapshotCount; j++) {
            if (done[j]) continue;
            int similarity = similarity(allInfos[i][t], allInfos[j][t]);
            if (similarity > maxSim) {
              maxSim = similarity;
              similars = new boolean[threadElementsSnapshotCount];
            }
            if (similarity == maxSim) similars[j] = true;
          }
          // print out trace maxSim levels of i, and mark similar ones as done
          int count = 1;
          for (int j = i + 1; j < threadElementsSnapshotCount; j++) {
            if (similars[j]) {
              done[j] = true;
              count++;
            }
          }
          if (allInfos[i][t] != null) {
            final StackTraceElement[] show = allInfos[i][t].getStackTrace();
            if (count == 1) {
              sb.append(String.format(Locale.ROOT, "  unique snapshot%n"));
              for (int l = 0; l < show.length; l++) {
                sb.append(String.format(Locale.ROOT, "    %s%n", show[l]));
              }
            } else {
              sb.append(
                  String.format(
                      Locale.ROOT,
                      "  %d/%d snapshots sharing following %d elements%n",
                      count,
                      threadElementsSnapshotCount,
                      maxSim));
              for (int l = show.length - maxSim; l < show.length; l++) {
                sb.append(String.format(Locale.ROOT, "    %s%n", show[l]));
              }
            }
          }
        }
      }
      return sb.toString();
    } finally {
      if (enabledCpu) {
        threadBean.setThreadCpuTimeEnabled(false);
      }
    }
  }