SignalApp.py 3.21 KB
Newer Older
German Leon's avatar
German Leon committed
1
2
3
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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
import time
from classes.Logging import Logging
from threading  import Thread
from random import uniform

import common_parameters as cp  # All common parameters will bet at common_parameters module
import os
import sys

"""
Signal the app to stop so GDB can execute the script to flip a value
"""


class SignalApp(Thread):
    def __init__(self, signal_cmd, max_wait_time, log_path, unique_id, signals_to_send, init_sleep, syncro,waitfinish):
        global hang
        hang=False
        super(SignalApp, self).__init__()
        self.__signal_cmd = signal_cmd
        os.system("rm -f {}".format(log_path))
        self.__log = Logging(log_file=log_path, unique_id=unique_id)

        # Most of the benchmarks we cannot wait until the end of the processing
        # Considering most of 90% of the time
        #self.__init_wait_time = uniform(init_sleep, max_wait_time * cp.MAX_SIGNAL_BEFORE_ENDING)
        self.__init_wait_time = uniform(0, max_wait_time * cp.MAX_SIGNAL_BEFORE_ENDING)
        self.__signals_to_send = signals_to_send
        self.__time_to_sleep = (max_wait_time - self.__init_wait_time) / self.__signals_to_send
       # self.__time_to_sleep = (max_wait_time) / self.__signals_to_send
        self._syncro=syncro
        self._waitfinish=waitfinish
    def run(self):
        # Send a series of signal to make sure gdb will flip a value in one of the interrupt signals
        log_string = "Sending a signal using command: {} after {}s and each {}s.".format(self.__signal_cmd, self.__init_wait_time,self.__time_to_sleep)

        if cp.DEBUG:
            print(log_string)
      
        # Sleep for a random time
#        time.sleep(self.__init_wait_time)
#a=[ uniform.randint(1,1000) for _ in range(self.__signals_to_send))]
#a.sort()
        # os.system("{} > /dev/null 2>/dev/null".format(self.__signal_cmd))
        self.__log.info(log_string)
        try:
           (self._syncro).wait()
        #except threading.BrokenBarrierError:
        except:	
German Leon's avatar
German Leon committed
50
51
52
53
54
          (self._syncro).abort()
          print("Breakpoint inicial fuera de tiempo")
        (self._syncro).reset()   
        hang=True
        self.__log.info("Timeout syncron of breakpoint\n")
German Leon's avatar
German Leon committed
55
56
57
58
59
60
61
                
        # Time random
        #print ("INIT:"+str(self.__init_wait_time)+"sleep"+str())
        time.sleep(self.__init_wait_time)	   
        for signals in range(0, self.__signals_to_send):
            os.system("{} > /dev/null 2>/dev/null".format(self.__signal_cmd))
            self.__log.info("sending signal {}".format(signals))
German Leon's avatar
German Leon committed
62
63
64
65
66
67
68
            #try:
            #   (self._syncro).wait()
               #except threading.BrokenBarrierError:
            #except:	
            #   (self._syncro).abort()
            #   print("Breakpoint fuera de tiempo")
            #(self._syncro).reset()   
German Leon's avatar
German Leon committed
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
            time.sleep(self.__time_to_sleep)
        (self._syncro).reset() 
        try:
          (self._waitfinish).wait()
        #except  threading.BrokenBarrierError:
        except:	
          (self._waitfinish).abort()
          print("Hang timeout execution")
          hang=True
          self.__log.info("Timeout execution programa")  
        (self._waitfinish).reset()

    def ishang (self):
        return hang
    def get_int_wait_time(self):
        return self.__init_wait_time