mirror of
https://github.com/ThomasKing2014/android-firmware-qti-sdm660
synced 2025-11-23 17:25:21 +08:00
481 lines
16 KiB
Perl
Executable File
481 lines
16 KiB
Perl
Executable File
use POSIX;
|
|
use File::Path;
|
|
# Written by Waleed Eshmawy
|
|
#$Hex_img_size = $ARGV[0];
|
|
#$Dec_img_size = hex($ARGV[0]);
|
|
#$Hex_image_start_addr = $ARGV[1];
|
|
#$Dec_image_start_addr = hex($ARGV[1]);
|
|
$image_name=$ARGV[0];
|
|
$CHIPSET_folder = $ARGV[1];
|
|
$BUILD_Flavour = $ARGV[2];
|
|
|
|
$HexMemSize{"SIZE_16M"}="0x1000000";
|
|
$HexMemSize{"SIZE_8M"}="0x800000";
|
|
$HexMemSize{"SIZE_4M"}="0x400000";
|
|
$HexMemSize{"SIZE_2M"}="0x200000";
|
|
$HexMemSize{"SIZE_1M"}="0x100000";
|
|
$HexMemSize{"SIZE_64K"}="0x10000";
|
|
$HexMemSize{"SIZE_32K"}="0x8000";
|
|
$HexMemSize{"SIZE_16K"}="0x4000";
|
|
$HexMemSize{"SIZE_8K"}="0x2000";
|
|
$HexMemSize{"SIZE_4K"}="0x1000";
|
|
$HexMemSize{"SIZE_2K"}="0x800";
|
|
$HexMemSize{"SIZE_1K"}="0x400";
|
|
$DecMemSize{"SIZE_16M"}=hex($HexMemSize{"SIZE_16M"});
|
|
$DexMemSize{"SIZE_8M"}=hex($HexMemSize{"SIZE_8M"});
|
|
$DecMemSize{"SIZE_4M"}=hex($HexMemSize{"SIZE_4M"});
|
|
$DecMemSize{"SIZE_2M"}=hex($HexMemSize{"SIZE_2M"});
|
|
$DecMemSize{"SIZE_1M"}=hex($HexMemSize{"SIZE_1M"});
|
|
$DecMemSize{"SIZE_64K"}=hex($HexMemSize{"SIZE_64K"});
|
|
$DecMemSize{"SIZE_32K"}=hex($HexMemSize{"SIZE_32K"});
|
|
$DecMemSize{"SIZE_16K"}=hex($HexMemSize{"SIZE_16K"});
|
|
$DecMemSize{"SIZE_8K"}=hex($HexMemSize{"SIZE_8K"});
|
|
$DecMemSize{"SIZE_4K"}=hex($HexMemSize{"SIZE_4K"});
|
|
$DecMemSize{"SIZE_2K"}=hex($HexMemSize{"SIZE_2K"});
|
|
$DecMemSize{"SIZE_1K"}=hex($HexMemSize{"SIZE_1K"});
|
|
|
|
#print "dec 16M = $DecMemSize{\"SIZE_16M\"}\n";
|
|
#print "Hex 16M = $HexMemSize{\"SIZE_16M\"}\n";
|
|
print "\nAnalyzing memory...\n\n";
|
|
|
|
#$output_file = "> memory.csv";
|
|
#open output_file or die "failed to open $output_file :$!";
|
|
|
|
|
|
#&getTotalHeap;
|
|
&getDefault_phy_mem_size;
|
|
#&getAPP_heapSize;
|
|
#&getStaticAllocatedMemSize;
|
|
&getImageAnalysis;
|
|
&getExternalHeapSize;
|
|
#&getFreeMemSize;
|
|
#&PrintOutput;
|
|
#&deleteMetafile;
|
|
|
|
if($FreeMem_size_d<0){
|
|
print "Run out of memory...\n";
|
|
print "Deleting $image_name\n";
|
|
# system("rm -f $image_name");
|
|
}
|
|
sub getTotalHeap {
|
|
$src_file = "./build/chipset/$CHIPSET_folder/q6_memory_defns.h";
|
|
open src_file or die "Cannot open file $src_file\n";
|
|
|
|
#print " 1. Trying to get the TotalHeap from $src_file\n";
|
|
|
|
while(<src_file>)
|
|
{
|
|
if ($_ =~ /TOTAL_HEAP/){
|
|
|
|
#print "line:$_\n";
|
|
@line_array = split(' ',$_);
|
|
|
|
$Total_Heap =$line_array[2];
|
|
$Hex_heap_size=sprintf("0x%x00000", $Total_Heap);
|
|
$Dec_heap_size=hex($Hex_heap_size);
|
|
}
|
|
}
|
|
if (!$Total_Heap ) {
|
|
print "the Total_Heap not found in $src_file\n";
|
|
exit;
|
|
}else{
|
|
|
|
#print " Heap size = $Hex_heap_size\n";
|
|
# print " Heap size d= $Dec_heap_size\n";
|
|
|
|
|
|
}
|
|
|
|
close $src_file;
|
|
}
|
|
sub getDefault_phy_mem_size {
|
|
$src_file = "./build/chipset/$CHIPSET_folder/qdsp6.xml";
|
|
open src_file or die "Cannot open file $src_file\n";
|
|
|
|
print " 1. Trying to get the DEFAULT_PHYSPOOL start address and size from $src_file\n";
|
|
$lineCnt=0;
|
|
$def_phy_pool_line_offset=-1;
|
|
$tracesizelineoffset = -1;
|
|
|
|
while(<src_file>)
|
|
{
|
|
if ($_ =~ /DEFAULT_PHYSPOOL/){
|
|
|
|
#print "default phy pool section line num :$lineCnt\n";
|
|
$def_phy_pool_line_offset=0;
|
|
|
|
}
|
|
if ($_ =~ /trace_size/){
|
|
|
|
#print "default phy pool section line num :$lineCnt\n";
|
|
#print"The trace size line is printed";
|
|
$tracesizelineoffset=0;
|
|
#print "trace line is: $_";
|
|
#die"out";
|
|
|
|
}
|
|
if($tracesizelineoffset == 0)
|
|
{
|
|
$tracesizelineoffset =1;
|
|
#print "line:$_\n";
|
|
$traceline=$_;
|
|
if($traceline =~ /.+\"(\d+)\".+/)
|
|
{
|
|
$tracesize = $1;
|
|
$tracesize = $tracesize*3;
|
|
$tarcenum=$tracesize/1024;
|
|
if($tarcenum <= 4)
|
|
{
|
|
$tracesizebytes=4*1024;
|
|
}
|
|
elsif(($tarcenum > 4) && ($tarcenum <= 16))
|
|
{
|
|
$tracesizebytes=16*1024;
|
|
}
|
|
elsif(($tarcenum > 16) && ($tarcenum <= 64))
|
|
{
|
|
$tracesizebytes=64*1024;
|
|
}
|
|
elsif(($tarcenum > 64) && ($tarcenum <= 256))
|
|
{
|
|
$tracesizebytes=256*1024;
|
|
}
|
|
#print"\n$tracesize\n";
|
|
}
|
|
$tracesizeinHWT=$tracesize*3;
|
|
#print "\n$tracesizeinMB\n";
|
|
#@trace_array = split('"',$_);
|
|
#print"\n@trace_array\n";
|
|
}
|
|
if($def_phy_pool_line_offset != -1){
|
|
$def_phy_pool_line_offset++;
|
|
if($def_phy_pool_line_offset ==3){
|
|
|
|
#get the start address
|
|
#print "line:$_\n";
|
|
$_ =~ s/ //g;
|
|
@line_array = split('"',$_);
|
|
# print "linearray = @line_array \n";
|
|
#@line_array1_1 =split('{',$line_array[0]);
|
|
#@line_array1_2 =split(',',$line_array1_1[1]);
|
|
# print "linearray0 = $line_array[0] \n";
|
|
|
|
#print "linearray1 = $line_array[1] \n";
|
|
#print "linearray2 = $line_array[2] \n";
|
|
#print "linearray3 = $line_array[3] \n";
|
|
$Hex_start_addr_from_file =$line_array[1];
|
|
$Dec_start_addr_from_file=hex($Hex_start_addr_from_file);
|
|
|
|
#get the size
|
|
#@line_array2_1 =split('}',$line_array[1]);
|
|
$Hex_img_size_from_file =$line_array[3];
|
|
$Dec_img_size_from_file=hex($Hex_img_size_from_file);
|
|
|
|
}
|
|
}
|
|
$lineCnt++;
|
|
}
|
|
if (!$Dec_start_addr_from_file ) {
|
|
print "the start_address not found in $src_file\n";
|
|
exit;
|
|
}else{
|
|
print " Start address = $Hex_start_addr_from_file";
|
|
|
|
}
|
|
if (!$Dec_img_size_from_file ) {
|
|
print "the image size not found in $src_file\n";
|
|
exit;
|
|
}else{
|
|
print " ,Image size defined = $Hex_img_size_from_file\n";
|
|
|
|
}
|
|
close $src_file;
|
|
}
|
|
|
|
sub getStaticAllocatedMemSize {
|
|
print output_file "QURT memory definition\n";
|
|
print output_file "Start addr,End addr,Size,Acess,Cache attribute,Comment \n";
|
|
$pgSize=0x1000;
|
|
$startPgAddr= $Hex_start_addr_from_file;
|
|
#$startPgAddr =~ s/000$//;
|
|
|
|
$src_file = "./qdsp6/qurt_overrides/8650/memmap.def";
|
|
open src_file or die "Cannot open file $src_file\n";
|
|
|
|
print " 3. Trying to get the size of static allocated memory definition from $src_file\n";
|
|
|
|
while(<src_file>)
|
|
{
|
|
if($_ !~ /^\// ){
|
|
|
|
$_ =~ s/\t//g;
|
|
$_ =~ s/ //g;
|
|
$_ =~ s/\r//;
|
|
$_ =~ s/\n//;
|
|
$_ =~ tr/[a-z]/[A-Z]/;
|
|
$_ =~ tr/X/x/;
|
|
|
|
if($_ =~ /^M/){
|
|
|
|
#print "s= $_";
|
|
@line_array = split(',',$_);
|
|
|
|
$mmGloble=$line_array[0];
|
|
$mmASID=$line_array[1];
|
|
$mmVPN=$line_array[2]."000";
|
|
#$mmACESS=$line_array[3];
|
|
#$mmCacheAttr=$line_array[4];
|
|
$mmPGSize=$line_array[5];
|
|
$mmPPN=$line_array[6]."000";
|
|
@line_array2 =split('\)',$_);
|
|
$mmComment=$line_array2[1];
|
|
#print "s= $_";
|
|
#push(@mmVPNarr,$mmVPN);
|
|
#print "mmVPN =$mmVPN\n";
|
|
#print "dec mmVPN =";
|
|
#print hex($mmVPN);
|
|
#print "\n";
|
|
$mmACESS{hex($mmVPN)}=$line_array[3];
|
|
$mmCacheAttr{hex($mmVPN)}=$line_array[4];
|
|
$mmVPN_DEC{hex($mmVPN)}=$mmVPN;
|
|
$Hash_comment{$mmVPN}=$mmComment;
|
|
$Total_Static_size{hex($mmVPN)}=$mmPGSize;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@mmVPN_DECarr = keys %mmVPN_DEC;
|
|
@mmVPN_DECarr = sort { $a <=> $b }@mmVPN_DECarr;
|
|
#@mmVPN_DECarr = sort(@mmVPN_DECarr);
|
|
#print "start address, end address, size, comment\n";
|
|
$staticStarted=-1;
|
|
$static_memory_size=0;
|
|
foreach (@mmVPN_DECarr){
|
|
#check for contigeous allocated static memory from the start address
|
|
|
|
|
|
$V_size=$DecMemSize{$Total_Static_size{$_}};
|
|
#print "v_size =$Total_Static_size{$_}= $V_size\n";
|
|
$V_end_addr =$_ + $V_size-1;
|
|
$V_end_addr = sprintf("0x%x", $V_end_addr);
|
|
$V_end_addr =~ tr/[a-z]/[A-Z]/;
|
|
$V_end_addr =~ tr/X/x/;
|
|
$V_size = sprintf("0x%x", $V_size);
|
|
if($staticStarted ==1){
|
|
if($mmVPN_DEC{$_} eq $nextCont_Startaddr){
|
|
$static_memory_size+=hex($V_size);
|
|
$hex_static_mem_size =sprintf ("0x%x",$static_memory_size);
|
|
$nextCont_Startaddr= hex($mmVPN_DEC{$_})+hex($V_size);
|
|
$nextCont_Startaddr = sprintf("0x%x", $nextCont_Startaddr);
|
|
$nextCont_Startaddr =~ tr/[a-z]/[A-Z]/;
|
|
$nextCont_Startaddr =~ tr/X/x/;
|
|
}else{
|
|
$staticStarted =-1;
|
|
# print "static memory ends, size = $hex_static_mem_size, external heap starts\n";
|
|
|
|
}
|
|
}
|
|
if($mmVPN_DEC{$_} eq $startPgAddr){
|
|
# print "static memory starts \n";
|
|
$staticStarted=1;
|
|
$static_memory_size+=hex($V_size);
|
|
$nextCont_Startaddr= hex($startPgAddr)+hex($V_size);
|
|
$nextCont_Startaddr = sprintf("0x%x", $nextCont_Startaddr);
|
|
$nextCont_Startaddr =~ tr/[a-z]/[A-Z]/;
|
|
$nextCont_Startaddr =~ tr/X/x/;
|
|
|
|
}
|
|
|
|
print output_file "$mmVPN_DEC{$_},$V_end_addr,$V_size,$mmACESS{$_},$mmCacheAttr{$_},$Hash_comment{$mmVPN_DEC{$_}} \n";
|
|
|
|
|
|
|
|
}
|
|
#@m_sorted_VPN_keys = sort{ $Total_Static_size{$a} <=> $Total_Static_size{$b} } @mmVPNarr;
|
|
#print "m_sorted keys : @m_sorted_VPN_keys\n";
|
|
if (!$hex_static_mem_size) {
|
|
print "\nStatic allocated memory not found!\n";
|
|
#exit;
|
|
}else{
|
|
print " Static allocated memory size = $hex_static_mem_size\n";
|
|
}
|
|
|
|
close $src_file;
|
|
}
|
|
|
|
sub getImageAnalysis {
|
|
|
|
print " 2. Trying to calculate the image size from $image_name\n";
|
|
system ("hexagon-objdump $image_name -h -w > section_info.txt");
|
|
if (open(SECTIONINFO,"section_info.txt")){
|
|
$sectionline=<SECTIONINFO>;
|
|
while ( $sectionline ne "" ) {
|
|
if($sectionline =~ /\d+\s+/)
|
|
{
|
|
@SectionInfoNames=split(/\s+/, $sectionline);
|
|
if(($SectionInfoNames[2] =~ /\.start/) || ($SectionInfoNames[2] =~ /\.start.+/))
|
|
{
|
|
$FirstSectionBase=hex($SectionInfoNames[4]);
|
|
$FirstSectionBasePhy=hex($SectionInfoNames[5]);
|
|
push(@mpdImageStart,$FirstSectionBase);
|
|
push(@mpdImageStartPhy,$FirstSectionBasePhy);
|
|
#print"\nstart address is:$FirstSectionBasePhy\n";
|
|
#print"\nTested address is : $SectionInfoNames[5]\n";
|
|
}
|
|
$decSectionBase=hex($SectionInfoNames[4]);
|
|
$decSectionBasePhy=hex($SectionInfoNames[5]);
|
|
if($decSectionBase != 0)
|
|
{
|
|
$LastSectionBase=$decSectionBase;
|
|
$LastSectionBasePhy=$decSectionBasePhy;
|
|
$LastSectionSize=hex($SectionInfoNames[3]);
|
|
$LastSectionEndAddress=$LastSectionBase+$LastSectionSize;
|
|
$LastSectionEndAddressPhy=$LastSectionBasePhy+$LastSectionSize;
|
|
}
|
|
else
|
|
{
|
|
push(@mpdImageEnd,$LastSectionEndAddress);
|
|
push(@mpdImageEndPhy,$LastSectionEndAddressPhy);
|
|
}
|
|
}
|
|
$sectionline=<SECTIONINFO>;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
die"Cannot Open File $section_file\n";
|
|
}
|
|
$len=@mpdImageStart;
|
|
$TotalMpdImageSize=0;
|
|
for($i=0;$i<$len;$i++)
|
|
{
|
|
#print"\nstart address is:$FirstSectionBasePhy\n";
|
|
#print"\nEnd address is: $LastSectionEndAddressPhy\n";
|
|
$TotalMpdImageSize+=$mpdImageEnd[$i]-$mpdImageStart[$i];
|
|
}
|
|
$arrayEnd=$len-1;
|
|
#print"\nlength is: $arrayEnd\n";
|
|
$OverallImageStart=$mpdImageStartPhy[0];
|
|
$OverallImageEnd=$mpdImageEndPhy[$arrayEnd];
|
|
$OveralImageEndNA=$OverallImageEnd - $OverallImageStart;
|
|
#print"\n$OverallImageEnd\n";
|
|
#print"\n$OverallImageStart\n";
|
|
$OverallImageEnd=ceil($OverallImageEnd/(256*1024));
|
|
#print"\nOverll size is : $OverallImageEnd\n";
|
|
$alignedImageEndPhy=$OverallImageEnd*256*1024;
|
|
$TotalMpdImageSizeMBFin=$alignedImageEndPhy - $OverallImageStart;
|
|
#print"\n$alignedImageEndPhy\n";
|
|
#print"\n$OverallImageStart\n";
|
|
#print"\n$TotalMpdImageSizeMBFin\n";
|
|
$TotalMpdImageSizeMBFinPhy=$TotalMpdImageSizeMBFin+$tracesizebytes;
|
|
$TotalMpdImageSizeMBFin=($TotalMpdImageSizeMBFin+$tracesizebytes)/(1024*1024);
|
|
#print"\n$tracesizebytes\n";
|
|
#print"\n$TotalMpdImageSizeMBFin\n";
|
|
$TotalMpdImageSizeMBFin=sprintf("%.2f", $TotalMpdImageSizeMBFin);
|
|
#print"\n$TotalMpdImageSizeMBFin\n";
|
|
$TotalMpdImageSizeMB=$TotalMpdImageSize/(1024*1024);
|
|
$TotalMpdImageSizeMB=sprintf("%.2f", $TotalMpdImageSizeMB);
|
|
$total_image_size_d=$TotalMpdImageSize;
|
|
$total_image_size_x=sprintf("0x%x",$TotalMpdImageSize);
|
|
|
|
close $section_file;
|
|
if(!$total_image_size_x){
|
|
print "The image size not found!\n";
|
|
exit;
|
|
|
|
|
|
}
|
|
|
|
}
|
|
sub getExternalHeapSize {
|
|
|
|
if(($TotalMpdImageSizeMBFinPhy) <= $Dec_img_size_from_file)
|
|
{
|
|
$Image_size_dec=hex($Hex_img_size_from_file);
|
|
$Image_size_dec = $Image_size_dec/(1024*1024);
|
|
$Static_size_dec = ($TotalMpdImageSize+$tracesizebytes)/(1024*1024);
|
|
$Static_size_dec = sprintf("%.2f", $Static_size_dec);
|
|
|
|
$Heap_size_dec = hex($Hex_heap_size);
|
|
$Heap_size_dec = $Heap_size_dec/(1024*1024);
|
|
print "*****************LPASS Memory FootPrint************************\n";
|
|
print "Total Image size declared in MB :$Image_size_dec\n";
|
|
print "Static(Text+Data)+Heap Memory size in MB :$Static_size_dec\n";
|
|
#print "Heap Memory size in MB :$Heap_size_dec\n";
|
|
print "Unused Memory size in KB:\n";
|
|
print " DEFAULT_PHYSPOOL - \(Static\(Text+Data\) Memory size - Heap Memory size\)\n";
|
|
print " $Image_size_dec - \($Static_size_dec\) \n";
|
|
$Dec_EXT_HeapSize = $Image_size_dec - ($Static_size_dec);
|
|
$Required_image_size=$Dec_EXT_HeapSize*1024;
|
|
print " =$Required_image_size\n";
|
|
print "**************************************************************\n";
|
|
}
|
|
else
|
|
{
|
|
print "\n";
|
|
print "****************************************\n";
|
|
print "Error: Static\(Text\+Data\) \+ Heap size is greater than DEFAULT_PHYSPOOL defined in qdsp6\.xml\n";
|
|
print "****************************************\n";
|
|
$Image_size_dec=hex($Hex_img_size_from_file);
|
|
$Image_size_decFin=$Image_size_dec;
|
|
$Image_size_dec = $Image_size_dec/(1024*1024);
|
|
$Image_size_decFinMB=$Image_size_dec;
|
|
$Image_size_dec = Image_size_dec - (256*1024);
|
|
$Image_size_decFin1=$Image_size_decFin-(256*1024);
|
|
$tobesaved= ($OveralImageEndNA+$tracesizebytes) - $Image_size_decFin1;
|
|
#print"\n$OveralImageEndNA\n";
|
|
#print"\n$tracesizebytes\n";
|
|
#print"\n$Image_size_decFin1\n";
|
|
$Static_size_dec = $TotalMpdImageSizeMBFinPhy/(1024*1024);
|
|
$Static_size_dec = sprintf("%.2f", $Static_size_dec);
|
|
#$Heap_size_dec = hex($Hex_heap_size);
|
|
#$Heap_size_dec = $Heap_size_dec/(1024*1024);
|
|
print "*****************LPASS Memory FootPrint************************\n";
|
|
print "Total Image size declared in MB :$Image_size_decFinMB\n";
|
|
print "Static(Text+Data)+Heap Memory size in MB :$Static_size_dec\n";
|
|
#print "Heap Memory size in MB :$Heap_size_dec\n";
|
|
if (($CHIPSET_folder eq "msm8x26") || ($CHIPSET_folder eq "msm8974") || ($CHIPSET_folder eq "msm8626"))
|
|
{
|
|
print "Mandatory Size that needs to be optimized in SensorPD to fit with in ADSP pool in KB:\n";
|
|
}
|
|
else
|
|
{
|
|
print "Mandatory Size that needs to be optimized to fit with in ADSP pool in KB:\n";
|
|
}
|
|
#print " DEFAULT_PHYSPOOL - \(Static\(Text+Data\) Memory size - Heap Memory size\)\n";
|
|
#print " $Image_size_dec - \($Static_size_dec\) \n";
|
|
$Dec_EXT_HeapSize = ($Static_size_dec) - $Image_size_dec;
|
|
$Required_image_size=$Dec_EXT_HeapSize*1024;
|
|
$Required_image_size1 = $tobesaved/1024;
|
|
print " =$Required_image_size1\n";
|
|
print "****************************************************************\n";
|
|
$filename="dsp\.elf";
|
|
unlink $filename;
|
|
#system("rm -rf \.\.\/dsp\.elf");
|
|
rmtree('obj\/qdsp6v5_ReleaseG');
|
|
#system("rm -rf \.\.\/obj\/qdsp6v5_ReleaseG");
|
|
}
|
|
|
|
|
|
}
|
|
|
|
sub PrintOutput {
|
|
|
|
print output_file "\n\nStatic allocated memory analysis\n";
|
|
print output_file "PAddr_start(Hex),PAddr_end(Hex),SIZE(Byte),Section Name,PADING(Byte)\n";
|
|
foreach (@m_sorted_keys) {
|
|
print output_file "$pa_x_start{$_},$pa_x_end{$_},$size_x{$_},$name{$_},$padding_x{$_}\n";
|
|
}
|
|
|
|
print output_file "Subtotal,,$tot_size_withoutPadding_x,,$tot_padding_x\n\n";
|
|
print output_file ",,,Total,$total_image_size_x\n";
|
|
close $output_file;
|
|
|
|
}
|
|
sub deleteMetafile {
|
|
# system ("rm -f section_info.txt");
|
|
}
|