1 /* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2009 Benjamin Poirier <benjamin.poirier@polymtl.ca>
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License Version 2 as
6 * published by the Free Software Foundation;
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
19 #define _ISOC99_SOURCE
25 #include <linux/if_ether.h>
27 #include <netinet/in.h>
32 #include "sync_chain.h"
33 #include "event_processing_lttng_common.h"
35 #include "event_processing_lttng_standard.h"
39 #define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format)
43 // Functions common to all processing modules
44 static void initProcessingLTTVStandard(SyncState
* const syncState
,
45 LttvTracesetContext
* const traceSetContext
);
46 static void destroyProcessingLTTVStandard(SyncState
* const syncState
);
48 static void finalizeProcessingLTTVStandard(SyncState
* const syncState
);
49 static void printProcessingStatsLTTVStandard(SyncState
* const syncState
);
50 static void writeProcessingGraphsOptionsLTTVStandard(SyncState
* const
51 syncState
, const unsigned int i
, const unsigned int j
);
53 // Functions specific to this module
54 static void registerProcessingLTTVStandard() __attribute__((constructor (102)));
55 static gboolean
processEventLTTVStandard(void* hookData
, void* callData
);
56 static void partialDestroyProcessingLTTVStandard(SyncState
* const syncState
);
59 static ProcessingModule processingModuleLTTVStandard
= {
60 .name
= "LTTV-standard",
61 .initProcessing
= &initProcessingLTTVStandard
,
62 .destroyProcessing
= &destroyProcessingLTTVStandard
,
63 .finalizeProcessing
= &finalizeProcessingLTTVStandard
,
64 .printProcessingStats
= &printProcessingStatsLTTVStandard
,
65 .writeProcessingGraphsPlots
= NULL
,
66 .writeProcessingGraphsOptions
= &writeProcessingGraphsOptionsLTTVStandard
,
72 * Processing Module registering function
74 static void registerProcessingLTTVStandard()
76 g_queue_push_tail(&processingModules
, &processingModuleLTTVStandard
);
83 * Allocate and initialize data structures for synchronizing a traceset.
84 * Register event hooks.
87 * syncState: container for synchronization data.
88 * This function allocates these processingData members:
93 * traceSetContext: set of LTTV traces
95 static void initProcessingLTTVStandard(SyncState
* const syncState
, LttvTracesetContext
*
96 const traceSetContext
)
99 ProcessingDataLTTVStandard
* processingData
;
101 processingData
= malloc(sizeof(ProcessingDataLTTVStandard
));
102 syncState
->processingData
= processingData
;
103 processingData
->traceSetContext
= traceSetContext
;
105 if (syncState
->stats
)
107 processingData
->stats
= calloc(1, sizeof(ProcessingStatsLTTVStandard
));
111 processingData
->stats
= NULL
;
114 processingData
->traceNumTable
= g_hash_table_new(&g_direct_hash
, NULL
);
115 processingData
->hookListList
= g_array_sized_new(FALSE
, FALSE
,
116 sizeof(GArray
*), syncState
->traceNb
);
117 processingData
->pendingRecv
= malloc(sizeof(GHashTable
*) *
120 for(i
= 0; i
< syncState
->traceNb
; i
++)
122 g_hash_table_insert(processingData
->traceNumTable
,
123 processingData
->traceSetContext
->traces
[i
]->t
, (gpointer
) i
);
126 if (syncState
->graphsStream
)
128 processingData
->graphs
= malloc(syncState
->traceNb
*
129 sizeof(ProcessingGraphsLTTVStandard
));
131 for(i
= 0; i
< syncState
->traceNb
; i
++)
133 LttTrace
* traceI
= traceSetContext
->traces
[i
]->t
;
135 processingData
->graphs
[i
].startFreq
= traceI
->start_freq
;
136 processingData
->graphs
[i
].freqScale
= traceI
->freq_scale
;
141 processingData
->graphs
= NULL
;
144 for(i
= 0; i
< syncState
->traceNb
; i
++)
146 processingData
->pendingRecv
[i
]= g_hash_table_new_full(&g_direct_hash
,
147 NULL
, NULL
, &gdnDestroyEvent
);
150 registerHooks(processingData
->hookListList
, traceSetContext
,
151 &processEventLTTVStandard
, syncState
,
152 syncState
->matchingModule
->canMatch
);
157 * Call the partial processing destroyer, obtain and adjust the factors from
161 * syncState container for synchronization data.
163 static void finalizeProcessingLTTVStandard(SyncState
* const syncState
)
167 double minOffset
, minDrift
;
168 unsigned int refFreqTrace
;
169 ProcessingDataLTTVStandard
* processingData
;
171 processingData
= (ProcessingDataLTTVStandard
*) syncState
->processingData
;
173 partialDestroyProcessingLTTVStandard(syncState
);
175 factors
= syncState
->matchingModule
->finalizeMatching(syncState
);
177 /* The offsets are adjusted so the lowest one is 0. This is done because
178 * of a Lttv specific limitation: events cannot have negative times. By
179 * having non-negative offsets, events cannot be moved backwards to
183 for (i
= 0; i
< syncState
->traceNb
; i
++)
185 minOffset
= MIN(g_array_index(factors
, Factors
, i
).offset
, minOffset
);
188 for (i
= 0; i
< syncState
->traceNb
; i
++)
190 g_array_index(factors
, Factors
, i
).offset
-= minOffset
;
193 /* Because the timestamps are corrected at the TSC level (not at the
194 * LttTime level) all trace frequencies must be made equal. We choose to
195 * use the frequency of the system with the lowest drift
199 for (i
= 0; i
< syncState
->traceNb
; i
++)
201 if (g_array_index(factors
, Factors
, i
).drift
< minDrift
)
203 minDrift
= g_array_index(factors
, Factors
, i
).drift
;
207 g_assert(syncState
->traceNb
== 0 || minDrift
!= INFINITY
);
209 // Write the factors to the LttTrace structures
210 for (i
= 0; i
< syncState
->traceNb
; i
++)
213 Factors
* traceFactors
;
215 t
= processingData
->traceSetContext
->traces
[i
]->t
;
216 traceFactors
= &g_array_index(factors
, Factors
, i
);
218 t
->drift
= traceFactors
->drift
;
219 t
->offset
= traceFactors
->offset
;
221 processingData
->traceSetContext
->traces
[refFreqTrace
]->t
->start_freq
;
223 processingData
->traceSetContext
->traces
[refFreqTrace
]->t
->freq_scale
;
224 t
->start_time_from_tsc
=
225 ltt_time_from_uint64(tsc_to_uint64(t
->freq_scale
, t
->start_freq
,
226 t
->drift
* t
->start_tsc
+ t
->offset
));
229 g_array_free(factors
, TRUE
);
231 lttv_traceset_context_compute_time_span(processingData
->traceSetContext
,
232 &processingData
->traceSetContext
->time_span
);
234 g_debug("traceset start %ld.%09ld end %ld.%09ld\n",
235 processingData
->traceSetContext
->time_span
.start_time
.tv_sec
,
236 processingData
->traceSetContext
->time_span
.start_time
.tv_nsec
,
237 processingData
->traceSetContext
->time_span
.end_time
.tv_sec
,
238 processingData
->traceSetContext
->time_span
.end_time
.tv_nsec
);
243 * Print statistics related to processing Must be called after
244 * finalizeProcessing.
247 * syncState container for synchronization data.
249 static void printProcessingStatsLTTVStandard(SyncState
* const syncState
)
251 ProcessingDataLTTVStandard
* processingData
;
253 if (!syncState
->stats
)
258 processingData
= (ProcessingDataLTTVStandard
*) syncState
->processingData
;
260 printf("LTTV processing stats:\n");
261 printf("\treceived frames: %d\n", processingData
->stats
->totRecv
);
262 printf("\treceived frames that are IP: %d\n",
263 processingData
->stats
->totRecvIp
);
264 if (syncState
->matchingModule
->canMatch
[TCP
])
266 printf("\treceived and processed packets that are TCP: %d\n",
267 processingData
->stats
->totRecvTCP
);
269 if (syncState
->matchingModule
->canMatch
[UDP
])
271 printf("\treceived and processed packets that are UDP: %d\n",
272 processingData
->stats
->totRecvUDP
);
274 if (syncState
->matchingModule
->canMatch
[TCP
])
276 printf("\tsent packets that are TCP: %d\n",
277 processingData
->stats
->totOutE
);
283 * Unregister event hooks. Deallocate processingData.
286 * syncState: container for synchronization data.
287 * This function deallocates these processingData members:
290 static void destroyProcessingLTTVStandard(SyncState
* const syncState
)
292 ProcessingDataLTTVStandard
* processingData
;
294 processingData
= (ProcessingDataLTTVStandard
*) syncState
->processingData
;
296 if (processingData
== NULL
)
301 partialDestroyProcessingLTTVStandard(syncState
);
303 if (syncState
->stats
)
305 free(processingData
->stats
);
308 if (syncState
->graphsStream
)
310 free(processingData
->graphs
);
313 free(syncState
->processingData
);
314 syncState
->processingData
= NULL
;
319 * Unregister event hooks. Deallocate some of processingData.
321 * This function can be called right after the events have been processed to
322 * free some data structures that are not needed for finalization.
325 * syncState: container for synchronization data.
326 * This function deallocates these members:
331 static void partialDestroyProcessingLTTVStandard(SyncState
* const syncState
)
334 ProcessingDataLTTVStandard
* processingData
;
336 processingData
= (ProcessingDataLTTVStandard
*) syncState
->processingData
;
338 if (processingData
== NULL
|| processingData
->traceNumTable
== NULL
)
343 g_hash_table_destroy(processingData
->traceNumTable
);
344 processingData
->traceNumTable
= NULL
;
346 for(i
= 0; i
< syncState
->traceNb
; i
++)
349 g_debug("Cleaning up pendingRecv list\n");
350 g_hash_table_destroy(processingData
->pendingRecv
[i
]);
352 free(processingData
->pendingRecv
);
354 unregisterHooks(processingData
->hookListList
,
355 processingData
->traceSetContext
);
360 * Lttv hook function that will be called for network events
363 * hookData: LttvTraceHook* for the type of event that generated the call
364 * callData: LttvTracefileContext* at the moment of the event
367 * FALSE Always returns FALSE, meaning to keep processing hooks for
370 static gboolean
processEventLTTVStandard(void* hookData
, void* callData
)
372 LttvTraceHook
* traceHook
;
373 LttvTracefileContext
* tfc
;
379 unsigned long traceNum
;
380 struct marker_info
* info
;
381 SyncState
* syncState
;
382 ProcessingDataLTTVStandard
* processingData
;
384 traceHook
= (LttvTraceHook
*) hookData
;
385 tfc
= (LttvTracefileContext
*) callData
;
386 trace
= tfc
->t_context
->t
;
387 syncState
= (SyncState
*) traceHook
->hook_data
;
388 processingData
= (ProcessingDataLTTVStandard
*) syncState
->processingData
;
389 event
= ltt_tracefile_get_event(tfc
->tf
);
390 info
= marker_get_info_from_id(tfc
->tf
->mdata
, event
->event_id
);
391 tsc
= ltt_event_cycle_count(event
);
392 time
= ltt_event_time(event
);
393 wTime
.seconds
= time
.tv_sec
;
394 wTime
.nanosec
= time
.tv_nsec
;
396 g_assert(g_hash_table_lookup_extended(processingData
->traceNumTable
,
397 trace
, NULL
, (gpointer
*) &traceNum
));
399 g_debug("XXXX process event: time: %ld.%09ld trace: %ld (%p) name: %s ",
400 time
.tv_sec
, time
.tv_nsec
, traceNum
, trace
,
401 g_quark_to_string(info
->name
));
403 if (info
->name
== LTT_EVENT_DEV_XMIT_EXTENDED
)
407 if (!ltt_event_get_unsigned(event
,
408 lttv_trace_get_hook_field(traceHook
, 1)) == ETH_P_IP
||
409 !ltt_event_get_unsigned(event
,
410 lttv_trace_get_hook_field(traceHook
, 2)) == IPPROTO_TCP
)
415 if (!syncState
->matchingModule
->canMatch
[TCP
])
420 if (syncState
->stats
)
422 processingData
->stats
->totOutE
++;
425 outE
= malloc(sizeof(Event
));
426 outE
->traceNum
= traceNum
;
428 outE
->wallTime
= wTime
;
430 outE
->copy
= ©TCPEvent
;
431 outE
->destroy
= &destroyTCPEvent
;
432 outE
->event
.tcpEvent
= malloc(sizeof(TCPEvent
));
433 outE
->event
.tcpEvent
->direction
= OUT
;
434 outE
->event
.tcpEvent
->segmentKey
= malloc(sizeof(SegmentKey
));
435 outE
->event
.tcpEvent
->segmentKey
->connectionKey
.saddr
=
436 htonl(ltt_event_get_unsigned(event
,
437 lttv_trace_get_hook_field(traceHook
, 3)));
438 outE
->event
.tcpEvent
->segmentKey
->connectionKey
.daddr
=
439 htonl(ltt_event_get_unsigned(event
,
440 lttv_trace_get_hook_field(traceHook
, 4)));
441 outE
->event
.tcpEvent
->segmentKey
->tot_len
=
442 ltt_event_get_unsigned(event
, lttv_trace_get_hook_field(traceHook
,
444 outE
->event
.tcpEvent
->segmentKey
->ihl
= ltt_event_get_unsigned(event
,
445 lttv_trace_get_hook_field(traceHook
, 6));
446 outE
->event
.tcpEvent
->segmentKey
->connectionKey
.source
=
447 ltt_event_get_unsigned(event
, lttv_trace_get_hook_field(traceHook
,
449 outE
->event
.tcpEvent
->segmentKey
->connectionKey
.dest
=
450 ltt_event_get_unsigned(event
, lttv_trace_get_hook_field(traceHook
,
452 outE
->event
.tcpEvent
->segmentKey
->seq
= ltt_event_get_unsigned(event
,
453 lttv_trace_get_hook_field(traceHook
, 9));
454 outE
->event
.tcpEvent
->segmentKey
->ack_seq
=
455 ltt_event_get_unsigned(event
, lttv_trace_get_hook_field(traceHook
,
457 outE
->event
.tcpEvent
->segmentKey
->doff
= ltt_event_get_unsigned(event
,
458 lttv_trace_get_hook_field(traceHook
, 11));
459 outE
->event
.tcpEvent
->segmentKey
->ack
= ltt_event_get_unsigned(event
,
460 lttv_trace_get_hook_field(traceHook
, 12));
461 outE
->event
.tcpEvent
->segmentKey
->rst
= ltt_event_get_unsigned(event
,
462 lttv_trace_get_hook_field(traceHook
, 13));
463 outE
->event
.tcpEvent
->segmentKey
->syn
= ltt_event_get_unsigned(event
,
464 lttv_trace_get_hook_field(traceHook
, 14));
465 outE
->event
.tcpEvent
->segmentKey
->fin
= ltt_event_get_unsigned(event
,
466 lttv_trace_get_hook_field(traceHook
, 15));
468 syncState
->matchingModule
->matchEvent(syncState
, outE
);
470 g_debug("Output event done\n");
472 else if (info
->name
== LTT_EVENT_DEV_RECEIVE
)
476 if (syncState
->stats
)
478 processingData
->stats
->totRecv
++;
481 protocol
= ltt_event_get_unsigned(event
,
482 lttv_trace_get_hook_field(traceHook
, 1));
484 if (protocol
== ETH_P_IP
)
489 if (syncState
->stats
)
491 processingData
->stats
->totRecvIp
++;
494 inE
= malloc(sizeof(Event
));
495 inE
->traceNum
= traceNum
;
497 inE
->wallTime
= wTime
;
498 inE
->event
.tcpEvent
= NULL
;
499 inE
->copy
= ©Event
;
500 inE
->destroy
= &destroyEvent
;
502 skb
= (void*) (long) ltt_event_get_long_unsigned(event
,
503 lttv_trace_get_hook_field(traceHook
, 0));
504 g_hash_table_replace(processingData
->pendingRecv
[traceNum
], skb
,
507 g_debug("Adding inE %p for skb %p to pendingRecv\n", inE
, skb
);
514 else if (info
->name
== LTT_EVENT_TCPV4_RCV_EXTENDED
)
519 // Search pendingRecv for an event with the same skb
520 skb
= (void*) (long) ltt_event_get_long_unsigned(event
,
521 lttv_trace_get_hook_field(traceHook
, 0));
524 g_hash_table_lookup(processingData
->pendingRecv
[traceNum
], skb
);
527 // This should only happen in case of lost events
528 g_warning("No matching pending receive event found");
532 if (syncState
->stats
)
534 processingData
->stats
->totRecvTCP
++;
537 // If it's there, remove it and proceed with a receive event
538 g_hash_table_steal(processingData
->pendingRecv
[traceNum
], skb
);
541 inE
->event
.tcpEvent
= malloc(sizeof(TCPEvent
));
542 inE
->copy
= ©TCPEvent
;
543 inE
->destroy
= &destroyTCPEvent
;
544 inE
->event
.tcpEvent
->direction
= IN
;
545 inE
->event
.tcpEvent
->segmentKey
= malloc(sizeof(SegmentKey
));
546 inE
->event
.tcpEvent
->segmentKey
->connectionKey
.saddr
=
547 htonl(ltt_event_get_unsigned(event
,
548 lttv_trace_get_hook_field(traceHook
, 1)));
549 inE
->event
.tcpEvent
->segmentKey
->connectionKey
.daddr
=
550 htonl(ltt_event_get_unsigned(event
,
551 lttv_trace_get_hook_field(traceHook
, 2)));
552 inE
->event
.tcpEvent
->segmentKey
->tot_len
=
553 ltt_event_get_unsigned(event
,
554 lttv_trace_get_hook_field(traceHook
, 3));
555 inE
->event
.tcpEvent
->segmentKey
->ihl
=
556 ltt_event_get_unsigned(event
,
557 lttv_trace_get_hook_field(traceHook
, 4));
558 inE
->event
.tcpEvent
->segmentKey
->connectionKey
.source
=
559 ltt_event_get_unsigned(event
,
560 lttv_trace_get_hook_field(traceHook
, 5));
561 inE
->event
.tcpEvent
->segmentKey
->connectionKey
.dest
=
562 ltt_event_get_unsigned(event
,
563 lttv_trace_get_hook_field(traceHook
, 6));
564 inE
->event
.tcpEvent
->segmentKey
->seq
=
565 ltt_event_get_unsigned(event
,
566 lttv_trace_get_hook_field(traceHook
, 7));
567 inE
->event
.tcpEvent
->segmentKey
->ack_seq
=
568 ltt_event_get_unsigned(event
,
569 lttv_trace_get_hook_field(traceHook
, 8));
570 inE
->event
.tcpEvent
->segmentKey
->doff
=
571 ltt_event_get_unsigned(event
,
572 lttv_trace_get_hook_field(traceHook
, 9));
573 inE
->event
.tcpEvent
->segmentKey
->ack
=
574 ltt_event_get_unsigned(event
,
575 lttv_trace_get_hook_field(traceHook
, 10));
576 inE
->event
.tcpEvent
->segmentKey
->rst
=
577 ltt_event_get_unsigned(event
,
578 lttv_trace_get_hook_field(traceHook
, 11));
579 inE
->event
.tcpEvent
->segmentKey
->syn
=
580 ltt_event_get_unsigned(event
,
581 lttv_trace_get_hook_field(traceHook
, 12));
582 inE
->event
.tcpEvent
->segmentKey
->fin
=
583 ltt_event_get_unsigned(event
,
584 lttv_trace_get_hook_field(traceHook
, 13));
586 syncState
->matchingModule
->matchEvent(syncState
, inE
);
588 g_debug("TCP input event %p for skb %p done\n", inE
, skb
);
591 else if (info
->name
== LTT_EVENT_UDPV4_RCV_EXTENDED
)
596 // Search pendingRecv for an event with the same skb
597 skb
= (void*) (long) ltt_event_get_long_unsigned(event
,
598 lttv_trace_get_hook_field(traceHook
, 0));
601 g_hash_table_lookup(processingData
->pendingRecv
[traceNum
], skb
);
604 // This should only happen in case of lost events
605 g_warning("No matching pending receive event found");
611 if (syncState
->stats
)
613 processingData
->stats
->totRecvUDP
++;
616 // If it's there, remove it and proceed with a receive event
617 g_hash_table_steal(processingData
->pendingRecv
[traceNum
], skb
);
620 inE
->event
.udpEvent
= malloc(sizeof(UDPEvent
));
621 inE
->copy
= ©UDPEvent
;
622 inE
->destroy
= &destroyUDPEvent
;
623 inE
->event
.udpEvent
->direction
= IN
;
624 inE
->event
.udpEvent
->datagramKey
= malloc(sizeof(DatagramKey
));
625 inE
->event
.udpEvent
->datagramKey
->saddr
=
626 htonl(ltt_event_get_unsigned(event
,
627 lttv_trace_get_hook_field(traceHook
, 1)));
628 inE
->event
.udpEvent
->datagramKey
->daddr
=
629 htonl(ltt_event_get_unsigned(event
,
630 lttv_trace_get_hook_field(traceHook
, 2)));
631 inE
->event
.udpEvent
->unicast
= ltt_event_get_unsigned(event
,
632 lttv_trace_get_hook_field(traceHook
, 3)) == 0 ? false : true;
633 inE
->event
.udpEvent
->datagramKey
->ulen
=
634 ltt_event_get_unsigned(event
,
635 lttv_trace_get_hook_field(traceHook
, 4));
636 inE
->event
.udpEvent
->datagramKey
->source
=
637 ltt_event_get_unsigned(event
,
638 lttv_trace_get_hook_field(traceHook
, 5));
639 inE
->event
.udpEvent
->datagramKey
->dest
=
640 ltt_event_get_unsigned(event
,
641 lttv_trace_get_hook_field(traceHook
, 6));
642 dataStart
= ltt_event_get_long_unsigned(event
,
643 lttv_trace_get_hook_field(traceHook
, 7));
644 g_assert_cmpuint(sizeof(inE
->event
.udpEvent
->datagramKey
->dataKey
),
645 ==, sizeof(guint64
));
646 if (inE
->event
.udpEvent
->datagramKey
->ulen
- 8 >=
647 sizeof(inE
->event
.udpEvent
->datagramKey
->dataKey
))
649 memcpy(inE
->event
.udpEvent
->datagramKey
->dataKey
, &dataStart
,
650 sizeof(inE
->event
.udpEvent
->datagramKey
->dataKey
));
654 memset(inE
->event
.udpEvent
->datagramKey
->dataKey
, 0,
655 sizeof(inE
->event
.udpEvent
->datagramKey
->dataKey
));
656 memcpy(inE
->event
.udpEvent
->datagramKey
->dataKey
, &dataStart
,
657 inE
->event
.udpEvent
->datagramKey
->ulen
- 8);
660 syncState
->matchingModule
->matchEvent(syncState
, inE
);
662 g_debug("UDP input event %p for skb %p done\n", inE
, skb
);
667 g_assert_not_reached();
675 * Write the processing-specific options in the gnuplot script.
678 * syncState: container for synchronization data
679 * i: first trace number
680 * j: second trace number, garanteed to be larger than i
682 static void writeProcessingGraphsOptionsLTTVStandard(SyncState
* const
683 syncState
, const unsigned int i
, const unsigned int j
)
685 ProcessingDataLTTVStandard
* processingData
;
686 ProcessingGraphsLTTVStandard
* traceI
, * traceJ
;
688 processingData
= (ProcessingDataLTTVStandard
*) syncState
->processingData
;
690 traceI
= &processingData
->graphs
[i
];
691 traceJ
= &processingData
->graphs
[j
];
693 fprintf(syncState
->graphsStream
,
694 "set key inside right bottom\n"
695 "set xlabel \"Clock %1$u\"\n"
696 "set xtics nomirror\n"
697 "set ylabel \"Clock %3$u\"\n"
698 "set ytics nomirror\n"
699 "set x2label \"Clock %1$d (s)\"\n"
700 "set x2range [GPVAL_X_MIN / %2$.1f : GPVAL_X_MAX / %2$.1f]\n"
702 "set y2label \"Clock %3$d (s)\"\n"
703 "set y2range [GPVAL_Y_MIN / %4$.1f : GPVAL_Y_MAX / %4$.1f]\n"
704 "set y2tics\n", i
, (double) traceI
->startFreq
/ traceI
->freqScale
, j
,
705 (double) traceJ
->startFreq
/ traceJ
->freqScale
);