BaseTools: Move gPlatformFinalPcd to Datapipe and optimize size

[mirror_edk2.git] / BaseTools / Source / Python / AutoGen / AutoGenWorker.py

## @file\r
# Create makefile for MS nmake and GNU make\r
#\r
# Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>\r
# SPDX-License-Identifier: BSD-2-Clause-Patent\r
#\r
from __future__ import absolute_import\r
import multiprocessing as mp\r
import threading\r
from Common.Misc import PathClass\r
from AutoGen.ModuleAutoGen import ModuleAutoGen\r
from AutoGen.ModuleAutoGenHelper import WorkSpaceInfo,AutoGenInfo\r
import Common.GlobalData as GlobalData\r
import Common.EdkLogger as EdkLogger\r
import os\r
from Common.MultipleWorkspace import MultipleWorkspace as mws\r
from AutoGen.AutoGen import AutoGen\r
from Workspace.WorkspaceDatabase import BuildDB\r
try:\r
    from queue import Empty\r
except:\r
    from Queue import Empty\r
import traceback\r
import sys\r
from AutoGen.DataPipe import MemoryDataPipe\r
import logging\r
import time\r
\r
def clearQ(q):\r
    try:\r
        while True:\r
            q.get_nowait()\r
    except Empty:\r
        pass\r
\r
class LogAgent(threading.Thread):\r
    def __init__(self,log_q,log_level,log_file=None):\r
        super(LogAgent,self).__init__()\r
        self.log_q = log_q\r
        self.log_level = log_level\r
        self.log_file = log_file\r
    def InitLogger(self):\r
        # For DEBUG level (All DEBUG_0~9 are applicable)\r
        self._DebugLogger_agent = logging.getLogger("tool_debug_agent")\r
        _DebugFormatter = logging.Formatter("[%(asctime)s.%(msecs)d]: %(message)s", datefmt="%H:%M:%S")\r
        self._DebugLogger_agent.setLevel(self.log_level)\r
        _DebugChannel = logging.StreamHandler(sys.stdout)\r
        _DebugChannel.setFormatter(_DebugFormatter)\r
        self._DebugLogger_agent.addHandler(_DebugChannel)\r
\r
        # For VERBOSE, INFO, WARN level\r
        self._InfoLogger_agent = logging.getLogger("tool_info_agent")\r
        _InfoFormatter = logging.Formatter("%(message)s")\r
        self._InfoLogger_agent.setLevel(self.log_level)\r
        _InfoChannel = logging.StreamHandler(sys.stdout)\r
        _InfoChannel.setFormatter(_InfoFormatter)\r
        self._InfoLogger_agent.addHandler(_InfoChannel)\r
\r
        # For ERROR level\r
        self._ErrorLogger_agent = logging.getLogger("tool_error_agent")\r
        _ErrorFormatter = logging.Formatter("%(message)s")\r
        self._ErrorLogger_agent.setLevel(self.log_level)\r
        _ErrorCh = logging.StreamHandler(sys.stderr)\r
        _ErrorCh.setFormatter(_ErrorFormatter)\r
        self._ErrorLogger_agent.addHandler(_ErrorCh)\r
\r
        if self.log_file:\r
            if os.path.exists(self.log_file):\r
                os.remove(self.log_file)\r
            _Ch = logging.FileHandler(self.log_file)\r
            _Ch.setFormatter(_DebugFormatter)\r
            self._DebugLogger_agent.addHandler(_Ch)\r
\r
            _Ch= logging.FileHandler(self.log_file)\r
            _Ch.setFormatter(_InfoFormatter)\r
            self._InfoLogger_agent.addHandler(_Ch)\r
\r
            _Ch = logging.FileHandler(self.log_file)\r
            _Ch.setFormatter(_ErrorFormatter)\r
            self._ErrorLogger_agent.addHandler(_Ch)\r
\r
    def run(self):\r
        self.InitLogger()\r
        while True:\r
            log_message = self.log_q.get()\r
            if log_message is None:\r
                break\r
            if log_message.name == "tool_error":\r
                self._ErrorLogger_agent.log(log_message.levelno,log_message.getMessage())\r
            elif log_message.name == "tool_info":\r
                self._InfoLogger_agent.log(log_message.levelno,log_message.getMessage())\r
            elif log_message.name == "tool_debug":\r
                self._DebugLogger_agent.log(log_message.levelno,log_message.getMessage())\r
            else:\r
                self._InfoLogger_agent.log(log_message.levelno,log_message.getMessage())\r
\r
    def kill(self):\r
        self.log_q.put(None)\r
class AutoGenManager(threading.Thread):\r
    def __init__(self,autogen_workers, feedback_q,error_event):\r
        super(AutoGenManager,self).__init__()\r
        self.autogen_workers = autogen_workers\r
        self.feedback_q = feedback_q\r
        self.Status = True\r
        self.error_event = error_event\r
    def run(self):\r
        try:\r
            fin_num = 0\r
            while True:\r
                badnews = self.feedback_q.get()\r
                if badnews is None:\r
                    break\r
                if badnews == "Done":\r
                    fin_num += 1\r
                elif badnews == "QueueEmpty":\r
                    EdkLogger.debug(EdkLogger.DEBUG_9, "Worker %s: %s" % (os.getpid(), badnews))\r
                    self.TerminateWorkers()\r
                else:\r
                    EdkLogger.debug(EdkLogger.DEBUG_9, "Worker %s: %s" % (os.getpid(), badnews))\r
                    self.Status = False\r
                    self.TerminateWorkers()\r
                if fin_num == len(self.autogen_workers):\r
                    self.clearQueue()\r
                    for w in self.autogen_workers:\r
                        w.join()\r
                    break\r
        except Exception:\r
            return\r
\r
    def clearQueue(self):\r
        taskq = self.autogen_workers[0].module_queue\r
        logq = self.autogen_workers[0].log_q\r
        clearQ(taskq)\r
        clearQ(self.feedback_q)\r
        clearQ(logq)\r
        # Copy the cache queue itmes to parent thread before clear\r
        cacheq = self.autogen_workers[0].cache_q\r
        try:\r
            cache_num = 0\r
            while True:\r
                item = cacheq.get()\r
                if item == "CacheDone":\r
                    cache_num += 1\r
                else:\r
                    GlobalData.gModuleAllCacheStatus.add(item)\r
                if cache_num  == len(self.autogen_workers):\r
                    break\r
        except:\r
            print ("cache_q error")\r
\r
    def TerminateWorkers(self):\r
        self.error_event.set()\r
    def kill(self):\r
        self.feedback_q.put(None)\r
class AutoGenWorkerInProcess(mp.Process):\r
    def __init__(self,module_queue,data_pipe_file_path,feedback_q,file_lock,cache_q,log_q,error_event):\r
        mp.Process.__init__(self)\r
        self.module_queue = module_queue\r
        self.data_pipe_file_path =data_pipe_file_path\r
        self.data_pipe = None\r
        self.feedback_q = feedback_q\r
        self.PlatformMetaFileSet = {}\r
        self.file_lock = file_lock\r
        self.cache_q = cache_q\r
        self.log_q = log_q\r
        self.error_event = error_event\r
    def GetPlatformMetaFile(self,filepath,root):\r
        try:\r
            return self.PlatformMetaFileSet[(filepath,root)]\r
        except:\r
            self.PlatformMetaFileSet[(filepath,root)]  = filepath\r
            return self.PlatformMetaFileSet[(filepath,root)]\r
    def run(self):\r
        try:\r
            taskname = "Init"\r
            with self.file_lock:\r
                try:\r
                    self.data_pipe = MemoryDataPipe()\r
                    self.data_pipe.load(self.data_pipe_file_path)\r
                except:\r
                    self.feedback_q.put(taskname + ":" + "load data pipe %s failed." % self.data_pipe_file_path)\r
            EdkLogger.LogClientInitialize(self.log_q)\r
            loglevel = self.data_pipe.Get("LogLevel")\r
            if not loglevel:\r
                loglevel = EdkLogger.INFO\r
            EdkLogger.SetLevel(loglevel)\r
            target = self.data_pipe.Get("P_Info").get("Target")\r
            toolchain = self.data_pipe.Get("P_Info").get("ToolChain")\r
            archlist = self.data_pipe.Get("P_Info").get("ArchList")\r
\r
            active_p = self.data_pipe.Get("P_Info").get("ActivePlatform")\r
            workspacedir = self.data_pipe.Get("P_Info").get("WorkspaceDir")\r
            PackagesPath = os.getenv("PACKAGES_PATH")\r
            mws.setWs(workspacedir, PackagesPath)\r
            self.Wa = WorkSpaceInfo(\r
                workspacedir,active_p,target,toolchain,archlist\r
                )\r
            self.Wa._SrcTimeStamp = self.data_pipe.Get("Workspace_timestamp")\r
            GlobalData.gGlobalDefines = self.data_pipe.Get("G_defines")\r
            GlobalData.gCommandLineDefines = self.data_pipe.Get("CL_defines")\r
            GlobalData.gCommandMaxLength = self.data_pipe.Get('gCommandMaxLength')\r
            os.environ._data = self.data_pipe.Get("Env_Var")\r
            GlobalData.gWorkspace = workspacedir\r
            GlobalData.gDisableIncludePathCheck = False\r
            GlobalData.gFdfParser = self.data_pipe.Get("FdfParser")\r
            GlobalData.gDatabasePath = self.data_pipe.Get("DatabasePath")\r
\r
            GlobalData.gUseHashCache = self.data_pipe.Get("UseHashCache")\r
            GlobalData.gBinCacheSource = self.data_pipe.Get("BinCacheSource")\r
            GlobalData.gBinCacheDest = self.data_pipe.Get("BinCacheDest")\r
            GlobalData.gPlatformHashFile = self.data_pipe.Get("PlatformHashFile")\r
            GlobalData.gModulePreMakeCacheStatus = dict()\r
            GlobalData.gModuleMakeCacheStatus = dict()\r
            GlobalData.gHashChainStatus = dict()\r
            GlobalData.gCMakeHashFile = dict()\r
            GlobalData.gModuleHashFile = dict()\r
            GlobalData.gFileHashDict = dict()\r
            GlobalData.gEnableGenfdsMultiThread = self.data_pipe.Get("EnableGenfdsMultiThread")\r
            GlobalData.gPlatformFinalPcds = self.data_pipe.Get("gPlatformFinalPcds")\r
            GlobalData.file_lock = self.file_lock\r
            CommandTarget = self.data_pipe.Get("CommandTarget")\r
            pcd_from_build_option = []\r
            for pcd_tuple in self.data_pipe.Get("BuildOptPcd"):\r
                pcd_id = ".".join((pcd_tuple[0],pcd_tuple[1]))\r
                if pcd_tuple[2].strip():\r
                    pcd_id = ".".join((pcd_id,pcd_tuple[2]))\r
                pcd_from_build_option.append("=".join((pcd_id,pcd_tuple[3])))\r
            GlobalData.BuildOptionPcd = pcd_from_build_option\r
            module_count = 0\r
            FfsCmd = self.data_pipe.Get("FfsCommand")\r
            if FfsCmd is None:\r
                FfsCmd = {}\r
            GlobalData.FfsCmd = FfsCmd\r
            PlatformMetaFile = self.GetPlatformMetaFile(self.data_pipe.Get("P_Info").get("ActivePlatform"),\r
                                             self.data_pipe.Get("P_Info").get("WorkspaceDir"))\r
            while True:\r
                if self.error_event.is_set():\r
                    break\r
                module_count += 1\r
                try:\r
                    module_file,module_root,module_path,module_basename,module_originalpath,module_arch,IsLib = self.module_queue.get_nowait()\r
                except Empty:\r
                    EdkLogger.debug(EdkLogger.DEBUG_9, "Worker %s: %s" % (os.getpid(), "Fake Empty."))\r
                    time.sleep(0.01)\r
                    continue\r
                if module_file is None:\r
                    EdkLogger.debug(EdkLogger.DEBUG_9, "Worker %s: %s" % (os.getpid(), "Worker get the last item in the queue."))\r
                    self.feedback_q.put("QueueEmpty")\r
                    time.sleep(0.01)\r
                    continue\r
\r
                modulefullpath = os.path.join(module_root,module_file)\r
                taskname = " : ".join((modulefullpath,module_arch))\r
                module_metafile = PathClass(module_file,module_root)\r
                if module_path:\r
                    module_metafile.Path = module_path\r
                if module_basename:\r
                    module_metafile.BaseName = module_basename\r
                if module_originalpath:\r
                    module_metafile.OriginalPath = PathClass(module_originalpath,module_root)\r
                arch = module_arch\r
                target = self.data_pipe.Get("P_Info").get("Target")\r
                toolchain = self.data_pipe.Get("P_Info").get("ToolChain")\r
                Ma = ModuleAutoGen(self.Wa,module_metafile,target,toolchain,arch,PlatformMetaFile,self.data_pipe)\r
                Ma.IsLibrary = IsLib\r
                # SourceFileList calling sequence impact the makefile string sequence.\r
                # Create cached SourceFileList here to unify its calling sequence for both\r
                # CanSkipbyPreMakeCache and CreateCodeFile/CreateMakeFile.\r
                RetVal = Ma.SourceFileList\r
                if GlobalData.gUseHashCache and not GlobalData.gBinCacheDest and CommandTarget in [None, "", "all"]:\r
                    try:\r
                        CacheResult = Ma.CanSkipbyPreMakeCache()\r
                    except:\r
                        CacheResult = False\r
                        self.feedback_q.put(taskname)\r
\r
                    if CacheResult:\r
                        self.cache_q.put((Ma.MetaFile.Path, Ma.Arch, "PreMakeCache", True))\r
                        continue\r
                    else:\r
                        self.cache_q.put((Ma.MetaFile.Path, Ma.Arch, "PreMakeCache", False))\r
\r
                Ma.CreateCodeFile(False)\r
                Ma.CreateMakeFile(False,GenFfsList=FfsCmd.get((Ma.MetaFile.Path, Ma.Arch),[]))\r
                Ma.CreateAsBuiltInf()\r
                if GlobalData.gBinCacheSource and CommandTarget in [None, "", "all"]:\r
                    try:\r
                        CacheResult = Ma.CanSkipbyMakeCache()\r
                    except:\r
                        CacheResult = False\r
                        self.feedback_q.put(taskname)\r
\r
                    if CacheResult:\r
                        self.cache_q.put((Ma.MetaFile.Path, Ma.Arch, "MakeCache", True))\r
                        continue\r
                    else:\r
                        self.cache_q.put((Ma.MetaFile.Path, Ma.Arch, "MakeCache", False))\r
\r
        except Exception as e:\r
            EdkLogger.debug(EdkLogger.DEBUG_9, "Worker %s: %s" % (os.getpid(), str(e)))\r
            self.feedback_q.put(taskname)\r
        finally:\r
            EdkLogger.debug(EdkLogger.DEBUG_9, "Worker %s: %s" % (os.getpid(), "Done"))\r
            self.feedback_q.put("Done")\r
            self.cache_q.put("CacheDone")\r
\r
    def printStatus(self):\r
        print("Processs ID: %d Run %d modules in AutoGen " % (os.getpid(),len(AutoGen.Cache())))\r
        print("Processs ID: %d Run %d modules in AutoGenInfo " % (os.getpid(),len(AutoGenInfo.GetCache())))\r
        groupobj = {}\r
        for buildobj in BuildDB.BuildObject.GetCache().values():\r
            if str(buildobj).lower().endswith("dec"):\r
                try:\r
                    groupobj['dec'].append(str(buildobj))\r
                except:\r
                    groupobj['dec'] = [str(buildobj)]\r
            if str(buildobj).lower().endswith("dsc"):\r
                try:\r
                    groupobj['dsc'].append(str(buildobj))\r
                except:\r
                    groupobj['dsc'] = [str(buildobj)]\r
\r
            if str(buildobj).lower().endswith("inf"):\r
                try:\r
                    groupobj['inf'].append(str(buildobj))\r
                except:\r
                    groupobj['inf'] = [str(buildobj)]\r
\r
        print("Processs ID: %d Run %d pkg in WDB " % (os.getpid(),len(groupobj.get("dec",[]))))\r
        print("Processs ID: %d Run %d pla in WDB " % (os.getpid(),len(groupobj.get("dsc",[]))))\r
        print("Processs ID: %d Run %d inf in WDB " % (os.getpid(),len(groupobj.get("inf",[]))))\r