def _create_vsim_process(self):
        """
        Create the vsim process
        """
        ident = threading.current_thread().ident

        with self._lock:
            try:
                vsim_process = self._vsim_processes[ident]
                if vsim_process.is_alive():
                    return vsim_process
            except KeyError:
                pass

            transcript_id = self._transcript_id
            self._transcript_id += 1
            vsim_process = Process([join(self._prefix, "vsim"), "-c",
                                    "-l", join(dirname(self._modelsim_ini), "transcript%i" % transcript_id)])
            self._vsim_processes[ident] = vsim_process

        vsim_process.write("#VUNIT_RETURN\n")

        try:
            consumer = SilentOutputConsumer()
            vsim_process.consume_output(consumer)
        except Process.NonZeroExitCode:
            # Print output if background vsim process startup failed
            LOGGER.error("Failed to start re-usable background vsim process")
            print(consumer.output)
            raise

        return vsim_process

    def _create_vsim_process(self):
        """
        Create the vsim process
        """
        ident = threading.current_thread().ident

        with self._lock:
            try:
                vsim_process = self._vsim_processes[ident]
                if vsim_process.is_alive():
                    return vsim_process
            except KeyError:
                pass

            transcript_id = self._transcript_id
            self._transcript_id += 1
            vsim_process = Process([
                join(self._prefix, "vsim"), "-c", "-l",
                join(dirname(self._modelsim_ini),
                     "transcript%i" % transcript_id)])
            self._vsim_processes[ident] = vsim_process

        vsim_process.write("#VUNIT_RETURN\n")
        vsim_process.consume_output(silent_output_consumer)
        return vsim_process

    def simulate(self,  # pylint: disable=too-many-arguments, too-many-locals
                 output_path, library_name, entity_name, architecture_name, config):
        """
        Simulate with entity as top level using generics
        """
        assert config.pli == []

        ghdl_output_path = join(output_path, self.name)
        data_file_name = join(ghdl_output_path, "wave.%s" % self._gtkwave)
        if not exists(ghdl_output_path):
            os.makedirs(ghdl_output_path)

        launch_gtkwave = self._gtkwave is not None and not config.elaborate_only

        status = True
        try:
            cmd = []
            cmd += ['--elab-run']
            cmd += ['--std=%s' % self._std_str()]
            cmd += ['--work=%s' % library_name]
            cmd += ['--workdir=%s' % self._libraries[library_name]]
            cmd += ['-P%s' % path for path in self._libraries.values()]

            if self._has_output_flag():
                cmd += ['-o', join(ghdl_output_path, "%s-%s" % (entity_name, architecture_name))]
            cmd += config.options.get("ghdl_flags", [])

            cmd += [entity_name, architecture_name]

            for name, value in config.generics.items():
                cmd += ['-g%s=%s' % (name, value)]

            cmd += ['--assert-level=%s' % ("warning" if config.fail_on_warning else "error")]

            if config.disable_ieee_warnings:
                cmd += ["--ieee-asserts=disable"]

            if config.elaborate_only:
                cmd += ["--no-run"]

            if launch_gtkwave:
                if exists(data_file_name):
                    os.remove(data_file_name)
                if self._gtkwave == "ghw":
                    cmd += ['--wave=%s' % data_file_name]
                elif self._gtkwave == "vcd":
                    cmd += ['--vcd=%s' % data_file_name]

            proc = Process(['ghdl'] + cmd)
            proc.consume_output()
        except Process.NonZeroExitCode:
            status = False

        if launch_gtkwave:
            cmd = ["gtkwave"] + shlex.split(self._gtkwave_args) + [data_file_name]
            stdout.write("%s\n" % " ".join(cmd))
            subprocess.call(cmd)

        return status

 def compile_verilog_file(self, source_file_name, library_name):
     try:
         proc = Process(['vlog', '-sv', '-quiet', '-modelsimini', self._modelsim_ini,
                         '-work', library_name, source_file_name])
         proc.consume_output()
     except Process.NonZeroExitCode:
         return False
     return True

 def compile_vhdl_file(self, source_file_name, library_name, vhdl_standard):
     try:
         proc = Process(['vcom', '-quiet', '-modelsimini', self._modelsim_ini,
                         '-' + vhdl_standard, '-work', library_name, source_file_name])
         proc.consume_output()
     except Process.NonZeroExitCode:
         return False
     return True

    def test_parses_stderr(self):
        python_script = self.make_file("run_err.py", r"""
from sys import stderr
stderr.write("error\n")
""")
        process = Process([sys.executable, python_script])
        output = []
        process.consume_output(output.append)
        self.assertEqual(output, ["error"])

    def test_parses_stderr(self):
        python_script = self.make_file("run_err.py", r"""
from sys import stderr
stderr.write("error\n")
""")
        process = Process(["python", python_script])
        output = []
        process.consume_output(lambda line: output.append(line))
        self.assertEqual(output, ["error"])
        self.assertEqual(process.output, "error\n")

    def create_library(self, library_name, path):

        if not file_exists(dirname(path)):
            os.makedirs(dirname(path))

        if not file_exists(path):
            proc = Process(['vlib', '-unix', path])
            proc.consume_output(callback=None)

        try:
            proc = Process(['vmap', '-modelsimini', self._modelsim_ini, library_name])
            proc.consume_output(callback=None)
        except Process.NonZeroExitCode:
            pass

        match = self._vmap_pattern.search(proc.output)
        if match:
            do_vmap = not file_exists(match.group('dir'))
        else:
            do_vmap = False

        if 'No mapping for library' in proc.output:
            do_vmap = True

        if do_vmap:
            proc = Process(['vmap','-modelsimini', self._modelsim_ini, library_name, path])
            proc.consume_output(callback=None)

    def test_run_basic_subprocess(self):
        python_script = self.make_file("run_basic.py", r"""
from sys import stdout
stdout.write("foo\n")
stdout.write("bar\n")
""")

        output = []
        process = Process([sys.executable, python_script])
        process.consume_output(output.append)
        self.assertEqual(output, ["foo", "bar"])

def run_command(command, cwd=None, env=None):
    """
    Run a command
    """
    try:
        proc = Process(command, cwd=cwd, env=env)
        proc.consume_output()
        return True
    except Process.NonZeroExitCode:
        pass
    return False

def run_command(command):
    """
    Run a command
    """
    try:
        proc = Process(command)
        proc.consume_output()
        return True
    except Process.NonZeroExitCode:
        pass
    return False

 def compile_vhdl_file(self, source_file_name, library_name, vhdl_standard):
     """
     Compiles a vhdl file into a specific library using a specfic vhdl_standard
     """
     try:
         proc = Process([join(self._prefix, 'vcom'), '-dbg', '-quiet', '-j', dirname(self._library_cfg),
                         '-' + vhdl_standard, '-work', library_name, source_file_name])
         proc.consume_output()
     except Process.NonZeroExitCode:
         return False
     return True

    def supports_vhdl_package_generics(cls):
        """
        Returns True when this simulator supports VHDL package generics
        """
        proc = Process([join(cls.find_prefix(), 'vcom'), '-version'], env=cls.get_env())
        consumer = VersionConsumer()
        proc.consume_output(consumer)
        if consumer.major is not None:
            return consumer.minor >= 1 if consumer.major == 10 else consumer.major > 10

        return False

    def get_osvvm_coverage_api(cls):
        """
        Returns simulator name when OSVVM coverage API is supported, None otherwise.
        """
        proc = Process([join(cls.find_prefix(), 'vcom'), '-version'])
        consumer = VersionConsumer()
        proc.consume_output(consumer)
        if consumer.year is not None:
            if (consumer.year == 2016 and consumer.month >= 10) or (consumer.year > 2016):
                return cls.name

        return None

    def test_run_basic_subprocess(self):
        python_script = self.make_file("run_basic.py", r"""
from sys import stdout
stdout.write("foo\n")
stdout.write("bar\n")
""")

        output = []
        process = Process(["python", python_script])
        process.consume_output(lambda line: output.append(line))
        self.assertEqual(output, ["foo", "bar"])
        self.assertEqual(process.output, "foo\nbar\n")

    def test_output_is_parallel(self):
        python_script = self.make_file("run_timeout.py", r"""
from time import sleep
from sys import stdout
stdout.write("message\n")
stdout.flush()
sleep(1000)
""")

        process = Process([sys.executable, python_script])
        message = process.next_line()
        process.terminate()
        self.assertEqual(message, "message")

    def _run_batch_file(self, batch_file_name, gui=False):
        """
        Run a test bench in batch by invoking a new vsim process from the command line
        """

        try:
            args = [join(self._prefix, "vsim"), "-gui" if gui else "-c",
                    "-l", join(dirname(batch_file_name), "transcript"),
                    '-do', "source \"%s\"" % fix_path(batch_file_name)]

            proc = Process(args, cwd=dirname(self._sim_cfg_file_name))
            proc.consume_output()
        except Process.NonZeroExitCode:
            return False
        return True

 def compile_verilog_file(self, source_file_name, library_name, include_dirs):
     """
     Compiles a verilog file into a specific library
     """
     args = [join(self._prefix, 'vlog'), '-quiet', '-sv2k12', '-lc', self._library_cfg,
             '-work', library_name, source_file_name]
     for library in self._libraries.values():
         args += ["-l", library.name]
     for include_dir in include_dirs:
         args += ["+incdir+%s" % include_dir]
     try:
         proc = Process(args)
         proc.consume_output()
     except Process.NonZeroExitCode:
         return False
     return True

    def _run_batch_file(self, batch_file_name, gui=False):
        try:
            args = ['vsim', '-quiet',
                    "-l", join(dirname(batch_file_name), "transcript"),
                    '-do', "do %s" % fix_path(batch_file_name)]
            
            if gui:
                args.append('-gui')
            else:
                args.append('-c')

            proc = Process(args)
            proc.consume_output()
        except Process.NonZeroExitCode:
            return False
        return True

 def compile_vhdl_file(self, source_file_name, library_name, library_path, vhdl_standard):
     """
     Compile a vhdl file
     """
     try:
         cmd = ['ghdl', '-a', '--workdir=%s' % library_path,
                '--work=%s' % library_name,
                '--std=%s' % self._std_str()]
         for library_name, library_path in self._libraries.items():
             cmd += ["-P%s" % library_path]
         cmd += [source_file_name]
         proc = Process(cmd)
         proc.consume_output()
     except Process.NonZeroExitCode:
         return False
     return True