def create_stream_file(streamfile_dest, my_deque):
writer = CTFWriter.Writer(streamfile_dest)
clock = CTFWriter.Clock("A_clock")
clock.description = "Simple clock"
writer.add_clock(clock)
writer.add_environment_field("Python_version", str(sys.version_info))
stream_class = CTFWriter.StreamClass("test_stream")
stream_class.clock = clock
event_class = CTFWriter.EventClass("SimpleEvent")
# Create a int32_t equivalent type
int32_type = CTFWriter.IntegerFieldDeclaration(32)
int32_type.signed = True
event_class.add_field(int32_type, "value")
# Create a int32_t equivalent type for the event_id_count
int32_type = CTFWriter.IntegerFieldDeclaration(32)
int32_type.signed = True
event_class.add_field(int32_type, "event_id_count")
stream_class.add_event_class(event_class)
stream = writer.create_stream(stream_class)
for item in my_deque:
event = CTFWriter.Event(event_class)
clock.time = item["timestamp"]
integer_field = event.payload("value")
integer_field.value = item["value"]
integer_field = event.payload("event_id_count")
integer_field.value = item["event_id_counter"]
stream.append_event(event)
stream.flush()
def convert(self, from_dir, to_dir):
tc = babeltrace.TraceCollection()
tc.add_trace(from_dir, "ctf")
clock = CTFWriter.Clock("clk")
writer = CTFWriter.Writer(to_dir)
writer.add_clock(clock)
stream_class = CTFWriter.StreamClass('trace')
stream_class.clock = clock
stream_class.packet_context_type.add_field(CTFWriter.IntegerFieldDeclaration(32), "cpu_id")
for id, clslst in self.handlers.items():
for cls in clslst:
for ev in cls.get_generated_events():
stream_class.add_event_class(ev)
stream = {}
for e in tc.events:
clock.time = e.timestamp
id = e["cpu_id"]
if id not in self.threads:
self.threads[id] = ThreadState(self.handlers)
stream[id] = writer.create_stream(stream_class)
stream[id].packet_context.field("cpu_id").value = id
evl = self.threads[id].consume(e)
for ev in evl:
stream[id].append_event(ev)
for s in stream.values():
s.flush()
def generate_composite_event(name, fields, static_fields):
ev = CTFWriter.EventClass(name)
for f in static_fields.keys():
ev.add_field(CTFWriter.StringFieldDeclaration(), f)
for f in fields:
ev.add_field(CTFWriter.IntegerFieldDeclaration(32), f)
return ev
def define_base_types(self):
self.char8_type = CTFWriter.IntegerFieldDeclaration(8)
self.char8_type.signed = True
self.char8_type.encoding = CTFStringEncoding.UTF8
self.char8_type.alignment = 8
self.int16_type = CTFWriter.IntegerFieldDeclaration(16)
self.int16_type.signed = True
self.int16_type.alignment = 8
self.uint16_type = CTFWriter.IntegerFieldDeclaration(16)
self.uint16_type.signed = False
self.uint16_type.alignment = 8
self.int32_type = CTFWriter.IntegerFieldDeclaration(32)
self.int32_type.signed = True
self.int32_type.alignment = 8
self.uint32_type = CTFWriter.IntegerFieldDeclaration(32)
self.uint32_type.signed = False
self.uint32_type.alignment = 8
self.int64_type = CTFWriter.IntegerFieldDeclaration(64)
self.int64_type.signed = True
self.int64_type.alignment = 8
self.uint64_type = CTFWriter.IntegerFieldDeclaration(64)
self.uint64_type.signed = False
self.uint64_type.alignment = 8
self.array16_type = CTFWriter.ArrayFieldDeclaration(
self.char8_type, 16)
self.string_type = CTFWriter.StringFieldDeclaration()
def _define_base_types(self):
self.int8_type = CTFWriter.IntegerFieldDeclaration(8)
self.int8_type.signed = True
self.int8_type.alignment = 8
self.uint8_type = CTFWriter.IntegerFieldDeclaration(8)
self.uint8_type.signed = False
self.uint8_type.alignment = 8
self.int32_type = CTFWriter.IntegerFieldDeclaration(32)
self.int32_type.signed = True
self.int32_type.alignment = 8
self.uint32_type = CTFWriter.IntegerFieldDeclaration(32)
self.uint32_type.signed = False
self.uint32_type.alignment = 8
self.uint64_type = CTFWriter.IntegerFieldDeclaration(64)
self.uint64_type.signed = False
self.uint64_type.alignment = 8
self.uint64_hex_type = CTFWriter.IntegerFieldDeclaration(64)
self.uint64_hex_type.signed = False
self.uint64_hex_type.alignment = 8
self.uint64_hex_type.base = 16
self.string_type = CTFWriter.StringFieldDeclaration()
# the default frequency is 1 Ghz, that increments clock each nanosecond
clock = btw.Clock('my_clock')
clock.description = 'this is my clock'
#clock.offset_seconds = 18
#clock.time = 18
writer.add_clock(clock)
# create stream_profiler_1 stream class and assign our clock to it
stream_class = btw.StreamClass('stream_profiler_1')
stream_class.clock = clock
# create response_time event class, that stores all the response times collected by profiler_1
event_class = btw.EventClass('response_time')
# create one 8-bit unsigned integer field. This will be used for code ID.
int32_field_decl = btw.IntegerFieldDeclaration(32)
int32_field_decl.signed = False
# add this field declaration to response_time event class
event_class.add_field(int32_field_decl, 'ID_field')
# create one 32-bit signed integer field. This will be used for code ID.
int64_field_decl = btw.IntegerFieldDeclaration(64)
int64_field_decl.signed = False
# add this field declaration to response_time event class
event_class.add_field(int64_field_decl, 'timestamp_field')
# register response_time event class to stream_profiler_1 stream class
stream_class.add_event_class(event_class)
# create stream_profiler_1 stream
stream = writer.create_stream(stream_class)
trace_path = tempfile.mkdtemp()
print("Writing trace at {}".format(trace_path))
writer = CTFWriter.Writer(trace_path)
clock = CTFWriter.Clock("A_clock")
clock.description = "Simple clock"
writer.add_clock(clock)
writer.add_environment_field("Python_version", str(sys.version_info))
stream_class = CTFWriter.StreamClass("test_stream")
stream_class.clock = clock
char8_type = CTFWriter.IntegerFieldDeclaration(8)
char8_type.signed = True
char8_type.encoding = CTFStringEncoding.UTF8
char8_type.alignment = 8
int32_type = CTFWriter.IntegerFieldDeclaration(32)
int32_type.signed = True
int32_type.alignment = 8
uint32_type = CTFWriter.IntegerFieldDeclaration(32)
uint32_type.signed = False
uint32_type.alignment = 8
int64_type = CTFWriter.IntegerFieldDeclaration(64)
int64_type.signed = True
int64_type.alignment = 8
