#!/usr/local/bin/perl

 #

 # Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

 # All rights reserved.

 # This component and the accompanying materials are made available

 # under the terms of "Eclipse Public License v1.0"

 # which accompanies this distribution, and is available

 # at the URL "http://www.eclipse.org/legal/epl-v10.html".

 #

 # Initial Contributors:

 # Nokia Corporation - initial contribution.

 #

 # Contributors:

 #

 # Description:

 #  This script parses trace data produced by OST from FBS, using the the FBSCLI, 

 #  FBSERV and Symbian BTrace Hooks OST dictionaries, to produce a CSV output of

 #  the amount of bitmap memory used per-thread over a user-definable time

 #  granularity, since the start of the trace.

 # 

 #  To use, enable SYMBIAN_KERNEL_THREAD_IDENTIFICATION trace group in Symbian

 #  BTrace Hooks OST dictionary, GRAPHICS_RESOURCE_MANAGEMENT_SEMANTICS in FBSERV

 #  OST dictionary, and GRAPHICS_RESOURCE_MANAGEMENT_SEMANTICS, 

 #  GRAPHICS_RESOURCE_MANAGEMENT_FUNCTIONS and GRAPHICS_CONTROL_FUNCTIONS in

 #  FBSCLI OST dictionary. Once tracing is gathered, save trace output as ascii 

 #  and run this script against it. The resulting file can then be imported into

 #  a spreadsheet application to be visually processed.

 #  

 #  KNOWN DEFECTS:

 #  Once the log time goes beyond midnight, snapshots will stop being taken.

 #

 use strict;

 # Sanity checking of the command line parameters...

 if ($#ARGV == -1 || $ARGV[0] eq "help" || $ARGV[0] eq "/?")

 {

    print "\nusage: $0 filename [-h]\n";

    print "where\n";

    print " -h : Specifies the heartbeat in millisecs (default=10000)\n";

    exit;

 }

 ## Modifiable constants...

 my $CSV_DELIMITER = ',';

 # Time after start to take first snapshot, in millisecs

 my $firstHeartBeatTimeMS = 1000;

 # Default heartbeat in millisecs if none specified.

 my $heartBeatMS = 10000;

 ##

 ## Internal structures...

 ##

 my $heartBeatCount = 0;

 my $nextHeartBeatMS = -1;

 # A hash of thread names to the amount of bitmap memory they 

 # have used since the start of the trace.

 my %bmpMemoryPerThread = ();

 # A hash of bitmaps fully qualified by the session they belong to,

 # and their local handle (because bitmaps can have the same local

 # handle in different threads), mapped to their size in bytes.

 my %bmpMemoryByServerHandle = ();

 # Hash of FbsSessions to thread IDs.

 my %SessionThreadMap = ();

 # Array of the above hashes, one hash per heartbeat.

 my @arrayOfSnapshots;

 # Hashes of thread and process names to IDs.

 my %ThreadNames;

 my %ProcessNames;

 ##

 ## Command line options parsing...

 ## First arg is assumed to be the filename.

 ##

 for my $i (1..$#ARGV)

 {

    my $cma = $ARGV[$i];

    if ($cma =~ m/-h(\d*)/)

    {

       $heartBeatMS = $1;

    }

    else

    {

       print "Unrecognised parameter: $cma , ignoring...\n";

    }

 }

 ## Read from the file.

 ## Read the log into an array line by line.

 my $TRACE_FILENAME = $ARGV[0];

 open(INPUT_FILE, $TRACE_FILENAME) or die $!;

 my @traceLines = <INPUT_FILE>;

 ##

 ## Parse each line sequentially...

 ##

 foreach my $line (@traceLines)

 {

    my $timeFromMidnightMS;

    ## 

    ## If this line is about a new process, make a note of the name and the

    ## associated process id, so that FbsSessions can be mapped to their 

    ## thread by name.

    ##

    if ($line =~ /^.*Thread:Process name assigned;NThread:(.*);DProcess:(.*);Name:(.*)$/i)

    {

       my $threadId  = $1;

       my $processId = $2;

       my $processName = $3;

       $ProcessNames{$processId} = $processName ;

    }

    ## 

    ## If this line is about a new process, make a note of the name and the

    ## associated process id, so that FbsSessions can be mapped to their 

    ## thread by name when the csv is generated.

    ##

    if (($line =~ /^.*Thread:Thread created;NThread:(.*);DProcess:(.*);Name:(.*)$/i) ||

       ($line =~ /^.*Thread:Thread name assigned;NThread:(.*);DProcess:(.*);Name:(.*)$/i))

       {

       my $threadId  = $1;

       my $processId = $2;

       my $threadName = $3;

       my $fullThreadName = $ProcessNames{$processId} . ":" . $threadName;

       $ThreadNames{$threadId} = $fullThreadName;

    }

    ##

    ## Determine timestamp. If this time is beyond the heartbeat, 

    ## take a snapshot and 

    ##

    if ($line =~ /^(\d\d):(\d\d):(\d\d)\.(\d{3})/)

    {

       $timeFromMidnightMS = ((($1 * 3600) + ($2 * 60) + $3) * 1000) + $4;

       # Set up the time for the first snapshot.

       if ($nextHeartBeatMS == -1) 

       {

          $nextHeartBeatMS = $timeFromMidnightMS + $firstHeartBeatTimeMS;

       }

    }

    ##

    ## If heartbeat reached, take snapshot of bmp memory per thread

    ## and set next heartbeat time.

    ##

    while ($timeFromMidnightMS >= $nextHeartBeatMS)

    {

       $nextHeartBeatMS += $heartBeatMS;

       # take a snapshot of the current bitmap memory usage per thread

       while ((my $thread, my $bmpMemory) = each(%bmpMemoryPerThread))

       {

            $arrayOfSnapshots[$heartBeatCount]{$thread} = $bmpMemory;

       }

       $heartBeatCount++;

    }

    ## FBS Client-side traces.

    if ($line =~ m/\tFBSCLI: /)

    {

       ##

       ## If this line is an FBSCLI trace, and it contains iSSH then

       ## it gives a chance to map a client thread ID to a session handle.

       ## 

       if ( $line =~ m/iSSH=(\w*);.*Thread ID:(.*)$/)

       {

          my $ServerSessionHandle = $1;

          my $thread = $2;

          if ($thread ne "0x00000000")

          {

             $SessionThreadMap{$ServerSessionHandle} = $thread;

          }

       }

    }

    ## 

    ## FBS Server-side traces.

    ##

    if ($line =~ m/\tFBSERV: /)

    {

       ## The line must have a s= parameter to be useful - the session server handle.

       ## Any FBSERV line without this is not considered for parsing.

       if ($line =~ m/; iSSH=(\w*);/)

       {

          my $FbsSessionHandle = $1;

          my $thread = "Unknown Thread [Session=$FbsSessionHandle]";

          if (defined($SessionThreadMap{$FbsSessionHandle}))

          {

             $thread = $SessionThreadMap{$FbsSessionHandle};

          }

          if ($line =~ m/# Server resource destroyed; .*iH=(\w*);/)

          {

             my $bmpHandle = $1;

             my $bmpIdentifier = "$FbsSessionHandle:$bmpHandle";

             if (defined($bmpMemoryByServerHandle{$bmpIdentifier}))

             {

                $bmpMemoryPerThread{$thread} -= $bmpMemoryByServerHandle{$bmpIdentifier};

                delete $bmpMemoryByServerHandle{$bmpIdentifier};

             }

          }

          if ($line =~ m/# Server bitmap resized; .*iOldH=(\w*); iNewH=(\w*); newbytes=(\d*);/)

          {

             # When a bitmap is resized, the amount of memory held by the bitmap may change

             # and the bitmap localhandle will change.

             my $oldBmpHandle = $1;

             my $newBmpHandle = $2;

             my $newBmpBytes = $3;

             my $oldBmpIdentifier = "$FbsSessionHandle:$oldBmpHandle";

             my $newBmpIdentifier = "$FbsSessionHandle:$newBmpHandle";

             if (defined($bmpMemoryByServerHandle{$oldBmpIdentifier}))

             {

                $bmpMemoryPerThread{$thread} -= $bmpMemoryByServerHandle{$oldBmpIdentifier};

                delete $bmpMemoryByServerHandle{$oldBmpIdentifier};

             }

             $bmpMemoryPerThread{$thread} += $newBmpBytes;

             $bmpMemoryByServerHandle{$newBmpIdentifier} = $newBmpBytes;           

          }

          elsif ($line =~ m/#.*iOldH=(\w*); iNewH=(\w*);/)

          {

             # When a bitmap is compressed, cleaned or resized, the bitmap local handle changes

             my $oldBmpHandle = $1;

             my $newBmpHandle = $2;

             my $oldBmpIdentifier = "$FbsSessionHandle:$oldBmpHandle";

             my $newBmpIdentifier = "$FbsSessionHandle:$newBmpHandle";

             if (defined($bmpMemoryByServerHandle{$oldBmpIdentifier}))

             {

                my $bytes = $bmpMemoryByServerHandle{$oldBmpIdentifier};

                delete $bmpMemoryByServerHandle{$oldBmpIdentifier};

                $bmpMemoryByServerHandle{$newBmpIdentifier} = $bytes;

             }

          }

          elsif ($line =~ m/#.*iH=(\w*);.*bytes=(\d+);/)

          {

             # Duplication of a bitmap typically. When a bitmap is duplicated,

             # the memory is 'owned' by all threads that duplicate it.

             my $bmpHandle = $1;

             my $bmpBytes = $2;

             my $bmpIdentifier = "$FbsSessionHandle:$bmpHandle";

             $bmpMemoryPerThread{$thread} += $bmpBytes;

             $bmpMemoryByServerHandle{$bmpIdentifier} = $bmpBytes;

          }

       }

    }

 }

 close (INPUT_FILE);

 ##

 ## Make a map of unique threads across all snapshots

 ## This is so only one occurrence of each thread will appear

 ## in the csv file.

 ##

 my %uniqueThreads = ();

 for my $i (0..$#arrayOfSnapshots)

 {

    for my $thread (keys %{$arrayOfSnapshots[$i]})

    {

       $uniqueThreads{$thread} = 1;

    }

 }

 ##

 ## Start writing to file.

 ## First row, which contains the heartbeat number column headings...

 ##

 my $OUTPUT_FILENAME = sprintf("%s.csv", $TRACE_FILENAME);

 open(OUTPUT_FILE,">$OUTPUT_FILENAME") or die $!;

 print OUTPUT_FILE "Session$CSV_DELIMITER";

 for my $i (0..$heartBeatCount)

 {

     print OUTPUT_FILE "$i$CSV_DELIMITER";

 }

 ##

 ## For each subsequent row, print the first thread and the

 ## memory at each snapshot...

 ##

 print OUTPUT_FILE "\n";

 while ((my $thread, my $dummy) = each(%uniqueThreads))

 {

     # Resolve the thread to its full name...

     print OUTPUT_FILE "$thread";

     if (defined($ThreadNames{$thread}) )

     {

        my $threadName = $ThreadNames{$thread};

        print OUTPUT_FILE ":$threadName";

     }

     print OUTPUT_FILE "$CSV_DELIMITER";

     # print the memory use per thread, for each snapshot...

     for my $i (0..$#arrayOfSnapshots)

     {

        my %snapshot = %{$arrayOfSnapshots[$i]};

        while ((my $snapshotThread, my $bmpMemory) = each(%snapshot))

        {

            if ($snapshotThread eq $thread) 

            {

               print OUTPUT_FILE "$bmpMemory";

            }

        }

        print OUTPUT_FILE "$CSV_DELIMITER";

     }

     print OUTPUT_FILE "\n";

 }

 close (OUTPUT_FILE);