Changeset 13986


Ignore:
Timestamp:
Nov 7, 2019 2:37:59 PM (10 days ago)
Author:
jwedin
Message:

Moved the buildNodeCountMap implementation to Profiling.jrag. Changed so Counter is no longer an inner class on ASTNode. Renamed Counter to ASTNodeCounter. #5865

Location:
branches/dev-jw-2590/Compiler
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • branches/dev-jw-2590/Compiler/ModelicaCompiler/src/jastadd/UtilInterface.jrag

    r13967 r13986  
    1 import org.jmodelica.modelica.compiler.ASTNode.Counter;
    21
    32aspect UtilInterface {
     
    5958             */
    6059            public void tearDown() {}
    61         }
    62 
    63         private Map<Class, Counter> buildNodeCountMap;
    64         public Map<Class, Counter> getBuildNodeCountMap() {
    65             if (buildNodeCountMap == null) {
    66                 buildNodeCountMap = new HashMap<>();
    67             }
    68             return buildNodeCountMap;
    6960        }
    7061
  • branches/dev-jw-2590/Compiler/ModelicaMiddleEnd/src/jastadd/Profiling.jrag

    r13967 r13986  
    413413    public void ASTNode.dumpNodeCount(String file, UtilInterface util)
    414414            throws IOException {
    415         ArrayList<Counter> list = new ArrayList<Counter>();
     415        ArrayList<ASTNodeCounter> list = new ArrayList<ASTNodeCounter>();
    416416        list.addAll(util.getBuildNodeCountMap().values());
    417417        Collections.sort(list);
    418418        CodeStream out = new CodeStream(file);
    419         for (Counter c : list)
     419        for (ASTNodeCounter c : list)
    420420            out.println(c);
    421421        for (NodeCountExtra nce : nodeCountExtra)
     
    424424    }
    425425
    426     public void ASTNode.buildNodeCount(Map<Class,Counter> map) {
     426    public void ASTNode.buildNodeCount(Map<Class,ASTNodeCounter> map) {
    427427        addToNodeCount(map, getClass(), Profiler.getNodeSize(this, false), Profiler.getNodeSize(this, true));
    428428        for (NodeCountExtra nce : nodeCountExtra)
     
    433433    }
    434434
    435     private void ASTNode.addToNodeCount(Map<Class,Counter> map, Class cls, long local, long deep) {
     435    private void ASTNode.addToNodeCount(Map<Class,ASTNodeCounter> map, Class cls, long local, long deep) {
    436436        if (map.containsKey(cls))
    437437            map.get(cls).inc(local, deep);
    438438        else
    439             map.put(cls, new Counter(cls.getSimpleName(), local, deep));
     439            map.put(cls, new ASTNodeCounter(cls.getSimpleName(), local, deep));
    440440        if (cls != ASTNode.class)
    441441            addToNodeCount(map, cls.getSuperclass(), local, deep);
    442442    }
    443443
    444     public class ASTNode {
    445         public static class Counter implements Comparable<Counter> {
    446             private int n;
    447             private long sizeLocal;
    448             private long sizeDeep;
    449             private String s;
    450            
    451             private static int l = 0;
    452             private static String fmt = null;
    453            
    454             public Counter(String name, long local, long deep) {
    455                 s = name;
    456                 sizeLocal = 0;
    457                 sizeDeep = 0;
    458                 n = 0;
    459                 if (s.length() > l)
    460                     l = s.length();
    461                 inc(local, deep);
    462             }
    463            
    464             public void inc(long local, long deep) {
    465                 n++;
    466                 sizeLocal += local;
    467                 sizeDeep += deep;
    468             }
    469            
    470             public int compareTo(Counter c) {
    471                 return c.n - n;
    472             }
    473            
    474             public String toString() {
    475                 if (fmt == null)
    476                     fmt = "%-" + l + "s : %9d (%8s / %8s)";
    477                 return String.format(fmt, s, n, ASTNode.formatMem(sizeDeep), ASTNode.formatMem(sizeLocal));
    478             }
     444    public class ASTNodeCounter implements Comparable<ASTNodeCounter> {
     445        private int n;
     446        private long sizeLocal;
     447        private long sizeDeep;
     448        private String s;
     449       
     450        private static int l = 0;
     451        private static String fmt = null;
     452       
     453        public ASTNodeCounter(String name, long local, long deep) {
     454            s = name;
     455            sizeLocal = 0;
     456            sizeDeep = 0;
     457            n = 0;
     458            if (s.length() > l)
     459                l = s.length();
     460            inc(local, deep);
     461        }
     462       
     463        public void inc(long local, long deep) {
     464            n++;
     465            sizeLocal += local;
     466            sizeDeep += deep;
     467        }
     468       
     469        public int compareTo(ASTNodeCounter c) {
     470            return c.n - n;
     471        }
     472       
     473        public String toString() {
     474            if (fmt == null)
     475                fmt = "%-" + l + "s : %9d (%8s / %8s)";
     476            return String.format(fmt, s, n, ASTNode.formatMem(sizeDeep), ASTNode.formatMem(sizeLocal));
     477        }
     478    }
     479
     480    public class UtilInterface {
     481        private Map<Class, ASTNodeCounter> buildNodeCountMap;
     482        public Map<Class, ASTNodeCounter> getBuildNodeCountMap() {
     483            if (buildNodeCountMap == null) {
     484                buildNodeCountMap = new HashMap<>();
     485            }
     486            return buildNodeCountMap;
    479487        }
    480488    }
Note: See TracChangeset for help on using the changeset viewer.