tfeneuil
/
python-elmo
Bevaka 1
Stjärnmärk 0
Förgrening 0
Kod Ärenden 0 Pull-förfrågningar 0 Släpp 0 Wiki Aktiviteter
Python-ELMO is a Python library which offers an encapsulation of the binary tool ELMO, in order to manipulate it easily in Python and SageMath script.
Du kan inte välja fler än 25 ämnen Ämnen måste starta med en bokstav eller siffra, kan innehålla bindestreck ('-') och vara max 35 tecken långa.
7 Incheckningar
1 Gren
Träd: 93d76ecfc4
Grenar Taggar
${ item.name }
Skapa branchen ${ searchTerm }
från '93d76ecfc4'
${ noResults }
python-elmo/elmo/engine.py

engine.py 8.7KB
Rå Blame Historik 

  1. import numpy as np

  2. import os

  3. from enum import IntEnum, unique

  4. 

  5. from .utils import binary_writing

  6. from .config import ELMO_TOOL_REPOSITORY

  7. 

  8. @unique

  9. class Instruction(IntEnum):

  10.     EOR = 0

  11.     LSL = 1

  12.     STR = 2

  13.     LDR = 3

  14.     MUL = 4

  15.     OTHER = 5

  16.     

  17. # Short name for 'Instruction' class

  18. Instr = Instruction

  19. 

  20. PREVIOUS = 0

  21. CURRENT = 1

  22. SUBSEQUENT = 2

  23. 

  24. class ELMOEngine:

  25.     def __init__(self):

  26.         self.load_coefficients()

  27.         self.reset_points()

  28.     

  29.     def _extract_data(self, nb):

  30.         coeffs = self.coefficients[self.pos:self.pos+nb]

  31.         self.pos += nb

  32.         return coeffs

  33. 

  34.     def load_coefficients(self):

  35.         filename = os.path.join(

  36.             os.path.dirname(os.path.abspath(__file__)),

  37.             ELMO_TOOL_REPOSITORY,

  38.             'coeffs.txt',

  39.         )

  40.         self.coefficients = None

  41.         with open(filename, 'r') as _file:

  42.             self.coefficients = np.array([list(map(float, line.split())) for line in _file.readlines()[:2153]])

  43.         

  44.         if self.coefficients is None:

  45.             raise IOError('Problem to read the coefficients.')

  46.         

  47.         self.pos = 0

  48.         

  49.         self.constant = np.squeeze(self._extract_data(1))

  50.         

  51.         self.PrvInstr = self._extract_data(4)

  52.         self.SubInstr = self._extract_data(4)

  53.         

  54.         self.Operand1 = self._extract_data(32)

  55.         self.Operand2 = self._extract_data(32)

  56.         self.BitFlip1 = self._extract_data(32)

  57.         self.BitFlip2 = self._extract_data(32)

  58.         

  59.         self.HWOp1PrvInstr = self._extract_data(4)

  60.         self.HWOp2PrvInstr = self._extract_data(4)

  61.         self.HDOp1PrvInstr = self._extract_data(4)

  62.         self.HDOp2PrvInstr = self._extract_data(4)

  63.         self.HWOp1SubInstr = self._extract_data(4)

  64.         self.HWOp2SubInstr = self._extract_data(4)

  65.         self.HDOp1SubInstr = self._extract_data(4)

  66.         self.HDOp2SubInstr = self._extract_data(4)

  67.         

  68.         self.Operand1_bitinteractions = self._extract_data(496)

  69.         self.Operand2_bitinteractions = self._extract_data(496)

  70.         self.BitFlip1_bitinteractions = self._extract_data(496)

  71.         self.BitFlip2_bitinteractions = self._extract_data(496)

  72.     

  73.     def reset_points(self):

  74.         self.points = []

  75.         self.power = None

  76.         

  77.     def add_point(self, triplet, previous_ops, current_ops):

  78.         self.points.append((triplet, previous_ops, current_ops))

  79.     

  80.     def _dot(self, a, b):

  81.         return np.sum(a * b, axis=0)

  82.         

  83.     def calculate_point(self, triplet, previous_ops, current_ops, debug=False):

  84.         nb_points = triplet.shape[1]

  85.         instructiontype = triplet[CURRENT]

  86.         instructiontype = instructiontype % 5 # Type 5 = Instruction was not profiled

  87.                 

  88.         # Previous

  89.         previous_instruction_typedec = triplet[PREVIOUS]

  90.         previous_instruction_type = np.zeros((5, nb_points))

  91.         for i in range(nb_points):

  92.             if previous_instruction_typedec[i] < 5:

  93.                 previous_instruction_type[previous_instruction_typedec[i],i] = 1

  94.         

  95.         # Current

  96.         (current_op1_binary, hw_op1) = binary_writing(current_ops[0], with_hamming=True)

  97.         (current_op2_binary, hw_op2) = binary_writing(current_ops[1], with_hamming=True)

  98. 

  99.         (current_op1_bitflip, hd_op1) = binary_writing(previous_ops[0] ^ current_ops[0], with_hamming=True)

  100.         (current_op2_bitflip, hd_op2) = binary_writing(previous_ops[1] ^ current_ops[1], with_hamming=True)

  101.         

  102.         current_instruction_typedec = instructiontype

  103.         current_instruction_type = np.zeros((5, nb_points))

  104.         for i in range(nb_points):

  105.             if triplet[CURRENT,i] < 5:

  106.                 current_instruction_type[current_instruction_typedec[i],i] = 1

  107.         

  108.         # Subsequent

  109.         subsequent_instruction_typedec = triplet[SUBSEQUENT]

  110.         subsequent_instruction_type = np.zeros((5, nb_points))

  111.         for i in range(nb_points):

  112.             if subsequent_instruction_typedec[i] < 5:

  113.                 subsequent_instruction_type[subsequent_instruction_typedec[i],i] = 1

  114. 

  115.         # Component variables

  116.         PrvInstr_data = self._dot( previous_instruction_type[1:], self.PrvInstr[:,instructiontype] )

  117.         SubInstr_data = self._dot( subsequent_instruction_type[1:], self.SubInstr[:,instructiontype] )

  118.         

  119.         Operand1_data = self._dot( current_op1_binary, self.Operand1[:,instructiontype] )

  120.         Operand2_data = self._dot( current_op2_binary, self.Operand2[:,instructiontype] )

  121.         BitFlip1_data = self._dot( current_op1_bitflip, self.BitFlip1[:,instructiontype] )

  122.         BitFlip2_data = self._dot( current_op2_bitflip, self.BitFlip2[:,instructiontype] )

  123.         

  124.         HWOp1PrvInstr_data = hw_op1 * self._dot(previous_instruction_type[1:], self.HWOp1PrvInstr[:,instructiontype])

  125.         HWOp2PrvInstr_data = hw_op2 * self._dot(previous_instruction_type[1:], self.HWOp2PrvInstr[:,instructiontype])

  126.         HDOp1PrvInstr_data = hd_op1 * self._dot(previous_instruction_type[1:], self.HDOp1PrvInstr[:,instructiontype])

  127.         HDOp2PrvInstr_data = hd_op2 * self._dot(previous_instruction_type[1:], self.HDOp2PrvInstr[:,instructiontype])

  128.         HWOp1SubInstr_data = hw_op1 * self._dot(subsequent_instruction_type[1:], self.HWOp1SubInstr[:,instructiontype])

  129.         HWOp2SubInstr_data = hw_op2 * self._dot(subsequent_instruction_type[1:], self.HWOp2SubInstr[:,instructiontype])

  130.         HDOp1SubInstr_data = hd_op1 * self._dot(subsequent_instruction_type[1:], self.HDOp1SubInstr[:,instructiontype])

  131.         HDOp2SubInstr_data = hd_op2 * self._dot(subsequent_instruction_type[1:], self.HDOp2SubInstr[:,instructiontype])

  132.         

  133.         Operand1_bitinteractions_data = np.zeros((nb_points))

  134.         Operand2_bitinteractions_data = np.zeros((nb_points))

  135.         BitFlip1_bitinteractions_data = np.zeros((nb_points))

  136.         BitFlip2_bitinteractions_data = np.zeros((nb_points))

  137.         

  138.         count = 0

  139.         for i in range(32):

  140.             for j in range(i+1,32):

  141.                 Operand1_bitinteractions_data += self.Operand1_bitinteractions[count,instructiontype] * current_op1_binary[i] * current_op1_binary[j]

  142.                 Operand2_bitinteractions_data += self.Operand2_bitinteractions[count,instructiontype] * current_op2_binary[i] * current_op2_binary[j]

  143. 

  144.                 BitFlip1_bitinteractions_data += self.BitFlip1_bitinteractions[count,instructiontype] * current_op1_bitflip[i] * current_op1_bitflip[j]

  145.                 BitFlip2_bitinteractions_data += self.BitFlip2_bitinteractions[count,instructiontype] * current_op2_bitflip[i] * current_op2_bitflip[j]

  146. 

  147.                 count += 1

  148.                 

  149.         power = self.constant[instructiontype] \

  150.                     + PrvInstr_data + SubInstr_data \

  151.                     + Operand1_data + Operand2_data \

  152.                     + BitFlip1_data + BitFlip2_data \

  153.                     + HWOp1PrvInstr_data + HWOp2PrvInstr_data \

  154.                     + HDOp1PrvInstr_data + HDOp2PrvInstr_data \

  155.                     + HWOp1SubInstr_data + HWOp2SubInstr_data \

  156.                     + HDOp1SubInstr_data + HDOp2SubInstr_data \

  157.                     + Operand1_bitinteractions_data + Operand2_bitinteractions_data \

  158.                     + BitFlip1_bitinteractions_data + BitFlip2_bitinteractions_data

  159.         

  160.         for i in range(nb_points):

  161.             if triplet[CURRENT,i] == 5:

  162.                 power[i] = self.constant[triplet[CURRENT,i]]

  163.                 

  164.         if debug:

  165.             print([self.constant[instructiontype], \

  166.                        PrvInstr_data, SubInstr_data, \

  167.                        Operand1_data, Operand2_data, \

  168.                        BitFlip1_data, BitFlip2_data, \

  169.                        HWOp1PrvInstr_data, HWOp2PrvInstr_data, \

  170.                        HDOp1PrvInstr_data, HDOp2PrvInstr_data, \

  171.                        HWOp1SubInstr_data, HWOp2SubInstr_data, \

  172.                        HDOp1SubInstr_data, HDOp2SubInstr_data, \

  173.                        Operand1_bitinteractions_data, Operand2_bitinteractions_data, \

  174.                        BitFlip1_bitinteractions_data, BitFlip2_bitinteractions_data])

  175.         return power

  176.     

  177.     def run(self):

  178.         nb_points = len(self.points)

  179.         triplet = np.array([p[0] for p in self.points]).T # shape = (3, nb_points)

  180.         previous_ops = np.array([p[1] for p in self.points]).T # shape = (2, nb_points)

  181.         current_ops = np.array([p[2] for p in self.points]).T # shape = (2, nb_points)

  182.         

  183.         self.power = self.calculate_point(triplet, previous_ops, current_ops)

  184.     

  185.     def oneshot_point(self, triplet, previous_ops, current_ops):

  186.         self.reset_points()

  187.         self.add_point(triplet, previous_ops, current_ops)

  188.         self.run()

  189.         return self.power