Quadcap Embeddable Database

com/quadcap/jni/Jni.java

Go to the documentation of this file.

package com.quadcap.jni;

/* Copyright 2000 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;

/**
 * Interface to native hi-res timers.
 *
 * @author Stan Bailes
 */
public class Jni {
//#set defs(ENABLE_JNIxx) 1
//#autogen begin
//#autogen end

    //#ifdef ENABLE_JNI
//-    static {
//-        System.loadLibrary("Jni");
//-        System.out.println("Jni loaded");
//-    }
//-    public static native long getHiResTimer();
//-    public static native long getHiResFrequency();
//-    static boolean              silent = false;
    //#else
    public static long getHiResFrequency() {
        return 1000;
    }
    public static long getHiResTimer() {
        return System.currentTimeMillis();
    }
    static boolean              silent = true;
    //#endif

    long                        start = getHiResTimer();

    static int                  deferCount = 0;
    
    static double               F = (double)getHiResFrequency();
    public static Jni                  jni = new Jni(null);
    static String lastStat;
    
    public Jni() {
    }

    String                      name;
    
    public Jni(String name) {
        this.name = name;
    }

    public final double next() {
        //#ifdef ENABLE_JNI
//-        long mark = getHiResTimer();
//-        double d = 1000000000.0 * ((double)(mark - start)) / F;
//-        d = ((double)((long)d)) / 1000.0;
//-        start = getHiResTimer();
//-        return d;
        //#else
        return 0;
        //#endif
    }

    public final static double D() {
        return jni.next();
    }

    public final void reset() {
        //#ifdef ENABLE_JNI
//-        start = getHiResTimer();
        //#endif
    }

    public String toString() {
        return name + ": " + next();
    }

    int count = 0;

    final public void dump(String s) {
        //#ifdef ENABLE_JNI
//-        long mark = getHiResTimer();
//-        if (!silent && deferCount-- <= 0) {
//-            double d = 1000000000.0 * ((double)(mark - start)) / F;
//-            System.out.println(Thread.currentThread().getName() + ": " +
//-                               name + ": " + formatInterval(d, -1) + "    " +
//-                               s + "        " + (count++));
//-            start = getHiResTimer();
//-        }
        //#endif
    }

    static HashMap stats = new HashMap();
    
    final public void stat(String s) {
        //#ifdef ENABLE_JNI
//-        long mark = getHiResTimer();
//-        double d = 1000000000.0 * ((double)(mark - start)) / F;
//-        if (name != null) s = name + ": " + s;
//-        Stat stat = (Stat)stats.get(s);
//-        if (stat == null) {
//-            stat = new Stat(s);
//-            stats.put(s, stat);
//-        }
//-        if (lastStat != null) {
//-            stat.addPrev(lastStat);
//-        }
//-        lastStat = s;
//-        stat.add(d);
//-        start = getHiResTimer();
        //#endif
    }

    public static String formatInterval(double d, int pad) {
        String unit = "ns";
        if (false) {
            d = ((double)((long)d)) / 1000000.0;
            unit = "ms";
        } else {
            d = ((double)((long)d)) / 1000.0;
            unit = "us";
        }
        long dd = (long)d;
        String ds = String.valueOf(dd);
        long df = (long)((d - dd) * 100);
        String fs = String.valueOf(df);
        if (fs.length() < 2) fs = "0" + fs;
        String s = ds + "." + fs + " " + unit;
        if (pad > 0) {
            while (s.length() < pad) s = " " + s;
        }
        return s;
    }

    String rpad(String s, int n) {
        StringBuffer sb = new StringBuffer(s);
        while (sb.length() < n) sb.append(' ');
        return sb.toString();
    }

    class StatCompare implements Comparator {
        public int compare(Object a, Object b) {
            double da = ((Stat)a).getTotal();
            double db = ((Stat)b).getTotal();
            if (da > db) return -1;
            if (da < db) return 1;
            return 0;
        }
    }

    final public void clearStats(String x) {
        if (x == null) {
            stats = new HashMap();
        } else {
            Iterator iter = stats.values().iterator();
            while (iter.hasNext()) {
                Stat s = (Stat)iter.next();
                if (s.getName().startsWith(x)) {
                    iter.remove();
                }
            }
        }
        jni.reset();
    }

    final public void dumpStats(String x) {
        //#ifdef ENABLE_JNI
//-        ArrayList ss = new ArrayList();
//-        ss.addAll(stats.values());
//-        Collections.sort(ss, new StatCompare());
//-        if (x == null) {
//-            System.out.println("ALL Stats:");
//-        } else {
//-            System.out.println("Stats for " + x);
//-        }
//-        Iterator iter = ss.iterator();
//-        while (iter.hasNext()) {
//-            Stat stat = (Stat)iter.next();
//-            String s = stat.getName();
//-            if (x == null || s.startsWith(x)) {
//-                double d = stat.getAdjustedMean();
//-                double total = stat.getTotal();
//-                System.out.println(
//-                    formatInterval(total, 14) + "[" +
//-                    formatInterval(d, 12) + "/" + stat.getCount() + "] " +
//-                    rpad(stat.toString(), 66));
//-            }
//-        }
        //#endif
    }

    public void finalize() throws Throwable {
        dumpStats(null);
        super.finalize();
    }

    //#ifdef ENABLE_JNI
//-    public static void main(String args[]) {
//-        Jni t = new Jni("main");
//-        Object lock = new Object();
//-        long freq = Jni.getHiResFrequency();
//-        double F = (double)freq;
//-        long start = Jni.getHiResTimer();
//-        for (int i = 0; i < 1000; i++) continue;
//-        double ticks = (double)(Jni.getHiResTimer() - start);
//-        double elap = (ticks/freq) * 1000000.0;
//-        System.out.println("elapsed: " + elap + " us");
//-        System.out.println("freq: " + (freq / 1000000.0) + " Mhz");
//-        t.reset();
//-        for (int i = 0; i < 1000; i++) {
//-            System.currentTimeMillis();
//-            t.stat("currentTimeMillis");
//-            System.currentTimeMillis();
//-            t.stat("currentTimeMillis");
//-            System.currentTimeMillis();
//-            t.stat("currentTimeMillis");
//-            System.currentTimeMillis();
//-            t.stat("currentTimeMillis");
//-            System.currentTimeMillis();
//-            t.stat("currentTimeMillis");
//-            synchronized (lock) {
//-                t.stat("synchronized");
//-            }
//-            synchronized (lock) {
//-                t.stat("synchronized");
//-            }
//-            synchronized (lock) {
//-                t.stat("synchronized");
//-            }
//-            synchronized (lock) {
//-                t.stat("synchronized");
//-            }
//-            t.stat("noop");
//-            t.stat("noop");
//-            t.stat("noop");
//-            t.stat("noop");
//-        }
//-        t.dumpStats(null);
//-    }
    //#endif
}