Opcode.cpp 6.78 KB
Newer Older
1 2
/*
 * Copyright (C) 2008 Apple Inc. All rights reserved.
3
 * Copyright (C) 2008 Cameron Zwarich <cwzwarich@uwaterloo.ca>
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1.  Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 * 2.  Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
 *     its contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

30
#include "config.h"
31 32
#include "Opcode.h"

33
#if ENABLE(OPCODE_STATS)
34
#include <array>
35
#include <wtf/DataLog.h>
36 37
#endif

38 39
using namespace std;

40
namespace JSC {
41

42
const char* const opcodeNames[] = {
43
#define OPCODE_NAME_ENTRY(opcode, size) #opcode,
44 45
    FOR_EACH_OPCODE_ID(OPCODE_NAME_ENTRY)
#undef OPCODE_NAME_ENTRY
46 47
};

48
#if ENABLE(OPCODE_STATS)
49

50 51 52
long long OpcodeStats::opcodeCounts[numOpcodeIDs];
long long OpcodeStats::opcodePairCounts[numOpcodeIDs][numOpcodeIDs];
int OpcodeStats::lastOpcode = -1;
53

54
static OpcodeStats logger;
55

56
OpcodeStats::OpcodeStats()
57
{
58 59
    for (int i = 0; i < numOpcodeIDs; ++i)
        opcodeCounts[i] = 0;
60
    
61 62 63
    for (int i = 0; i < numOpcodeIDs; ++i)
        for (int j = 0; j < numOpcodeIDs; ++j)
            opcodePairCounts[i][j] = 0;
64 65
}

66
static int compareOpcodeIndices(const void* left, const void* right)
67
{
68 69
    long long leftValue = OpcodeStats::opcodeCounts[*(int*) left];
    long long rightValue = OpcodeStats::opcodeCounts[*(int*) right];
70
    
71 72 73 74 75 76 77 78
    if (leftValue < rightValue)
        return 1;
    else if (leftValue > rightValue)
        return -1;
    else
        return 0;
}

79
static int compareOpcodePairIndices(const void* left, const void* right)
80
{
81
    std::pair<int, int> leftPair = *(pair<int, int>*) left;
82
    long long leftValue = OpcodeStats::opcodePairCounts[leftPair.first][leftPair.second];
83
    std::pair<int, int> rightPair = *(pair<int, int>*) right;
84
    long long rightValue = OpcodeStats::opcodePairCounts[rightPair.first][rightPair.second];
85 86 87 88 89 90 91 92 93
    
    if (leftValue < rightValue)
        return 1;
    else if (leftValue > rightValue)
        return -1;
    else
        return 0;
}

94
OpcodeStats::~OpcodeStats()
95 96
{
    long long totalInstructions = 0;
97 98
    for (int i = 0; i < numOpcodeIDs; ++i)
        totalInstructions += opcodeCounts[i];
99 100
    
    long long totalInstructionPairs = 0;
101 102 103
    for (int i = 0; i < numOpcodeIDs; ++i)
        for (int j = 0; j < numOpcodeIDs; ++j)
            totalInstructionPairs += opcodePairCounts[i][j];
104

105
    std::array<int, numOpcodeIDs> sortedIndices;
106
    for (int i = 0; i < numOpcodeIDs; ++i)
107
        sortedIndices[i] = i;
108
    qsort(sortedIndices.data(), numOpcodeIDs, sizeof(int), compareOpcodeIndices);
109
    
110 111
    std::pair<int, int> sortedPairIndices[numOpcodeIDs * numOpcodeIDs];
    std::pair<int, int>* currentPairIndex = sortedPairIndices;
112 113
    for (int i = 0; i < numOpcodeIDs; ++i)
        for (int j = 0; j < numOpcodeIDs; ++j)
114 115
            *(currentPairIndex++) = std::make_pair(i, j);
    qsort(sortedPairIndices, numOpcodeIDs * numOpcodeIDs, sizeof(std::pair<int, int>), compareOpcodePairIndices);
116
    
117
    dataLogF("\nExecuted opcode statistics\n"); 
118
    
119
    dataLogF("Total instructions executed: %lld\n\n", totalInstructions);
120

121
    dataLogF("All opcodes by frequency:\n\n");
122

123
    for (int i = 0; i < numOpcodeIDs; ++i) {
124
        int index = sortedIndices[i];
125
        dataLogF("%s:%s %lld - %.2f%%\n", opcodeNames[index], padOpcodeName((OpcodeID)index, 28), opcodeCounts[index], ((double) opcodeCounts[index]) / ((double) totalInstructions) * 100.0);    
126 127
    }
    
128 129
    dataLogF("\n");
    dataLogF("2-opcode sequences by frequency: %lld\n\n", totalInstructions);
130
    
131
    for (int i = 0; i < numOpcodeIDs * numOpcodeIDs; ++i) {
132
        std::pair<int, int> indexPair = sortedPairIndices[i];
133
        long long count = opcodePairCounts[indexPair.first][indexPair.second];
134 135 136 137
        
        if (!count)
            break;
        
138
        dataLogF("%s%s %s:%s %lld %.2f%%\n", opcodeNames[indexPair.first], padOpcodeName((OpcodeID)indexPair.first, 28), opcodeNames[indexPair.second], padOpcodeName((OpcodeID)indexPair.second, 28), count, ((double) count) / ((double) totalInstructionPairs) * 100.0);
139 140
    }
    
141 142
    dataLogF("\n");
    dataLogF("Most common opcodes and sequences:\n");
143

144
    for (int i = 0; i < numOpcodeIDs; ++i) {
145
        int index = sortedIndices[i];
146 147 148
        long long opcodeCount = opcodeCounts[index];
        double opcodeProportion = ((double) opcodeCount) / ((double) totalInstructions);
        if (opcodeProportion < 0.0001)
149
            break;
150
        dataLogF("\n%s:%s %lld - %.2f%%\n", opcodeNames[index], padOpcodeName((OpcodeID)index, 28), opcodeCount, opcodeProportion * 100.0);
151

152
        for (int j = 0; j < numOpcodeIDs * numOpcodeIDs; ++j) {
153
            std::pair<int, int> indexPair = sortedPairIndices[j];
154
            long long pairCount = opcodePairCounts[indexPair.first][indexPair.second];
155 156
            double pairProportion = ((double) pairCount) / ((double) totalInstructionPairs);
        
157
            if (!pairCount || pairProportion < 0.0001 || pairProportion < opcodeProportion / 100)
158 159 160 161 162
                break;

            if (indexPair.first != index && indexPair.second != index)
                continue;

163
            dataLogF("    %s%s %s:%s %lld - %.2f%%\n", opcodeNames[indexPair.first], padOpcodeName((OpcodeID)indexPair.first, 28), opcodeNames[indexPair.second], padOpcodeName((OpcodeID)indexPair.second, 28), pairCount, pairProportion * 100.0);
164 165 166
        }
        
    }
167
    dataLogF("\n");
168 169
}

170
void OpcodeStats::recordInstruction(int opcode)
171
{
172
    opcodeCounts[opcode]++;
173
    
174 175
    if (lastOpcode != -1)
        opcodePairCounts[lastOpcode][opcode]++;
176
    
177
    lastOpcode = opcode;
178 179
}

180
void OpcodeStats::resetLastInstruction()
181
{
182
    lastOpcode = -1;
183 184 185 186
}

#endif

187
} // namespace JSC