WP6-17 - Revision history

Grolleaue: /* HW/SW CO-DEsign of HEterogeneous Parallel dedicated Systems (HEPSYCODE) */

2023-03-10T08:41:14Z

HW/SW CO-DEsign of HEterogeneous Parallel dedicated Systems (HEPSYCODE)

← Older revision		Revision as of 08:41, 10 March 2023
Line 18:		Line 18:
	\|-		\|-
	\| TRL \|\| 4		\| TRL \|\| 4
			\|-
			\| Contact \|\| mario.diferdinando at univaq.it
	\|}		\|}

Univaq at 12:38, 3 October 2022

2022-10-03T12:38:45Z

← Older revision		Revision as of 12:38, 3 October 2022
Line 34:		Line 34:
	The design activity in HEPSYCODE begins with a high-level abstraction modeling language (called HEPSYCODE Modeling Language, HML). The initial HML model is then transformed into an executable SystemC model based on the Communicating Sequential Processes (CSP) Model of Computation (MoC), first described by Hoare [9]. HEPSYCODE defines two system-level models, the SBM and the TL. The former is realized from the original HML. The latter contains all necessary and low-level hardware architectural details (e.g., PUs, MUs, CUs). Such models are supported by some C++ libraries that extend the standard SystemC library to implement CSP. The language of Communicating Sequential Processes (CSP) was developed for describing systems of interacting components and is supported by an underlying theory for reasoning about them.		The design activity in HEPSYCODE begins with a high-level abstraction modeling language (called HEPSYCODE Modeling Language, HML). The initial HML model is then transformed into an executable SystemC model based on the Communicating Sequential Processes (CSP) Model of Computation (MoC), first described by Hoare [9]. HEPSYCODE defines two system-level models, the SBM and the TL. The former is realized from the original HML. The latter contains all necessary and low-level hardware architectural details (e.g., PUs, MUs, CUs). Such models are supported by some C++ libraries that extend the standard SystemC library to implement CSP. The language of Communicating Sequential Processes (CSP) was developed for describing systems of interacting components and is supported by an underlying theory for reasoning about them.
	CSP processes are modeled by using classic SC_THREAD while CSP channels have been modeled by introducing a proper sc_csp_channel as better described later. A “CSP SC_THREAD” presents an init section and an infinite loop behavior while accessing only its local variables and so communicating with other “CSP SC_THREAD” only by means of CSP channels. Finally, in a “CSP SC_THREAD”, only basic C/C++ statements and C++/SystemC data types are allowed while avoiding a full OOP approach since it could introduce critical issues for estimation and HW synthesis activities (in fact, the adopted restrictions have been inspired by [10]). Since the SBM is based on CSP, the SystemC library has been extended to properly model CSP channels with a sc_csp_channel class.		CSP processes are modeled by using classic SC_THREAD while CSP channels have been modeled by introducing a proper sc_csp_channel as better described later. A “CSP SC_THREAD” presents an init section and an infinite loop behavior while accessing only its local variables and so communicating with other “CSP SC_THREAD” only by means of CSP channels. Finally, in a “CSP SC_THREAD”, only basic C/C++ statements and C++/SystemC data types are allowed while avoiding a full OOP approach since it could introduce critical issues for estimation and HW synthesis activities (in fact, the adopted restrictions have been inspired by [10]). Since the SBM is based on CSP, the SystemC library has been extended to properly model CSP channels with a sc_csp_channel class.
	HEPSYCODE supports the UML/MARTE modeling language for system modeling. The integration of UML/MARTE allows the designer to use one of the most used languages in the embedded systems industry ~~[17]~~. Moreover, MARTE is a standard UML profile to represent quantitative non-functional properties (e.g., time, performance). This variant of HEPSYCODE provides several steps of verification and validation (V&V) intending to discover eventual design flaws before the implementation. The novelty lies in the adoption of formal models to check the satisfiability of non-functional requirements and estimate system properties.		HEPSYCODE supports the UML/MARTE modeling language for system modeling. The integration of UML/MARTE allows the designer to use one of the most used languages in the embedded systems industry. Moreover, MARTE is a standard UML profile to represent quantitative non-functional properties (e.g., time, performance). This variant of HEPSYCODE provides several steps of verification and validation (V&V) intending to discover eventual design flaws before the implementation. The novelty lies in the adoption of formal models to check the satisfiability of non-functional requirements and estimate system properties.

	== Interoperability with other C4D tools ==		== Interoperability with other C4D tools ==

Univaq at 19:50, 22 September 2022

2022-09-22T19:50:05Z

← Older revision		Revision as of 19:50, 22 September 2022
Line 11:		Line 11:
	\| Provide \|\| Architectural solutions		\| Provide \|\| Architectural solutions
	\|-		\|-
	\| Input \|\| SystemC models, Platform model.		\| Input \|\| SystemC models, Platform model
	\|-		\|-
	\| Output \|\| HW/SW Partitioning, Mapping and Architecture Definition.		\| Output \|\| HW/SW Partitioning, Mapping and Architecture Definition
	\|-		\|-
	\| C4D tooling \|\| n.a.		\| C4D tooling \|\| n.a.

Univaq at 19:49, 22 September 2022

2022-09-22T19:49:49Z

← Older revision		Revision as of 19:49, 22 September 2022
Line 7:		Line 7:
	\| Levels \|\| Tool, Platform		\| Levels \|\| Tool, Platform
	\|-		\|-
	\| Require \|\| Linux, ~~TODO~~		\| Require \|\| Linux, SystemC code, UML/MARTE model
	\|-		\|-
	\| Provide \|\| ~~TODO~~		\| Provide \|\| Architectural solutions
	\|-		\|-
	\| Input \|\| SystemC models, Platform model~~, TODO~~		\| Input \|\| SystemC models, Platform model.
	\|-		\|-
	\| Output \|\| ~~TODO~~.		\| Output \|\| HW/SW Partitioning, Mapping and Architecture Definition.
	\|-		\|-
	\| C4D tooling \|\| n.a.		\| C4D tooling \|\| n.a.

Univaq at 19:29, 22 September 2022

2022-09-22T19:29:17Z

← Older revision		Revision as of 19:29, 22 September 2022
Line 48:		Line 48:
	[2] “Intel/Altera Cyclone V family”, http://www.intel.com		[2] “Intel/Altera Cyclone V family”, http://www.intel.com

	[3] J. Teich. ~~Hardware~~/software co-design: The past, the present, and predicting the ~~future~~. Proceedings of the IEEE, 100 (Special Centennial Issue):1411-1430, May 2012.		[3] J. Teich. “Hardware/software co-design: The past, the present, and predicting the future”. Proceedings of the IEEE, 100 (Special Centennial Issue):1411-1430, May 2012.

	[4] L. Pomante. “System-level design space exploration for dedicated heterogeneous multi-processor systems”. IEEE Int. Conf. on Application-specific Systems, Architectures, and Processors, 2011.		[4] L. Pomante. “System-level design space exploration for dedicated heterogeneous multi-processor systems”. IEEE Int. Conf. on Application-specific Systems, Architectures, and Processors, 2011.

	[5] L. Pomante, D. Sciuto, F. Salice, W. Fornaciari, C. Brandolese. ~~Affinity~~-Driven System Design Exploration for Heterogeneous Multiprocessor ~~SoC~~. IEEE Transactions on Computers, vol. 55, no. 5, May 2006.		[5] L. Pomante, D. Sciuto, F. Salice, W. Fornaciari, C. Brandolese. “Affinity-Driven System Design Exploration for Heterogeneous Multiprocessor SoC”. IEEE Transactions on Computers, vol. 55, no. 5, May 2006.

	[6] “HEPSYCODE”, https://www.hepsycode.com/.		[6] “HEPSYCODE”, https://www.hepsycode.com/.

	[7] Pomante, L., Muttillo, V., Santic, M., Serri, P. ~~SystemC~~-based electronic system-level design space exploration environment for dedicated heterogeneous multi-processor ~~systems~~. Microprocessors and Microsystems, 72, 2020		[7] Pomante, L., Muttillo, V., Santic, M., Serri, P. “SystemC-based electronic system-level design space exploration environment for dedicated heterogeneous multi-processor systems”. Microprocessors and Microsystems, 72, 2020

	[8] Frank Vahid and Tony Givargis. 2001. ~~Embedded~~ System Design: A Unified Hardware/Software ~~Introduction~~. John Wiley & Sons, Inc.		[8] Frank Vahid and Tony Givargis. 2001. “Embedded System Design: A Unified Hardware/Software Introduction”. John Wiley & Sons, Inc.

	[9] C. A. R. Hoare. 1978. ~~Communicating~~ sequential ~~processes~~. Commun. ACM 21, 8 (Aug. 1978), 666–677.		[9] C. A. R. Hoare. 1978. “Communicating sequential processes”. Commun. ACM 21, 8 (Aug. 1978), 666–677.

	[10] “SystemC Synthesis Subset Language Reference Manual”, https://www.accellera.org/community/systemc		[10] “SystemC Synthesis Subset Language Reference Manual”, https://www.accellera.org/community/systemc

Univaq at 19:28, 22 September 2022

2022-09-22T19:28:07Z

← Older revision		Revision as of 19:28, 22 September 2022
Line 44:		Line 44:
	==References==		==References==

	[1] ~~Xilinx~~ Zynq SoC ~~family~~, http://www.xilinx.com		[1] “Xilinx Zynq SoC family”, http://www.xilinx.com

	[2] ~~Intel~~/Altera Cyclone V ~~family~~, http://www.intel.com		[2] “Intel/Altera Cyclone V family”, http://www.intel.com

	[3] J. Teich. Hardware/software co-design: The past, the present, and predicting the future. Proceedings of the IEEE, 100 (Special Centennial Issue):1411-1430, May 2012.		[3] J. Teich. Hardware/software co-design: The past, the present, and predicting the future. Proceedings of the IEEE, 100 (Special Centennial Issue):1411-1430, May 2012.
Line 54:		Line 54:
	[5] L. Pomante, D. Sciuto, F. Salice, W. Fornaciari, C. Brandolese. Affinity-Driven System Design Exploration for Heterogeneous Multiprocessor SoC. IEEE Transactions on Computers, vol. 55, no. 5, May 2006.		[5] L. Pomante, D. Sciuto, F. Salice, W. Fornaciari, C. Brandolese. Affinity-Driven System Design Exploration for Heterogeneous Multiprocessor SoC. IEEE Transactions on Computers, vol. 55, no. 5, May 2006.

	[6] ~~HEPSYCODE~~, https://www.hepsycode.com/.		[6] “HEPSYCODE”, https://www.hepsycode.com/.

	[7] Pomante, L., Muttillo, V., Santic, M., Serri, P. SystemC-based electronic system-level design space exploration environment for dedicated heterogeneous multi-processor systems. Microprocessors and Microsystems, 72, 2020		[7] Pomante, L., Muttillo, V., Santic, M., Serri, P. SystemC-based electronic system-level design space exploration environment for dedicated heterogeneous multi-processor systems. Microprocessors and Microsystems, 72, 2020
Line 60:		Line 60:
	[8] Frank Vahid and Tony Givargis. 2001. Embedded System Design: A Unified Hardware/Software Introduction. John Wiley & Sons, Inc.		[8] Frank Vahid and Tony Givargis. 2001. Embedded System Design: A Unified Hardware/Software Introduction. John Wiley & Sons, Inc.

	[9] ~~Hoare~~ C.A.R. (1978) Communicating ~~Sequential Processes~~. ~~In: Hansen P~~.B. ~~(eds~~) ~~The Origin of Concurrent Programming~~. ~~Springer, New York, NY~~		[9] C. A. R. Hoare. 1978. Communicating sequential processes. Commun. ACM 21, 8 (Aug. 1978), 666–677.

	[10] “SystemC Synthesis Subset Language Reference Manual”, https://www.accellera.org/community/systemc		[10] “SystemC Synthesis Subset Language Reference Manual”, https://www.accellera.org/community/systemc

Univaq at 19:26, 22 September 2022

2022-09-22T19:26:20Z

← Older revision		Revision as of 19:26, 22 September 2022
Line 31:		Line 31:

	==Contribution and Improvements==		==Contribution and Improvements==
	~~Some key aspects of the HEPSYCODE flow for design system improvement are:~~

	* TODO		The design activity in HEPSYCODE begins with a high-level abstraction modeling language (called HEPSYCODE Modeling Language, HML). The initial HML model is then transformed into an executable SystemC model based on the Communicating Sequential Processes (CSP) Model of Computation (MoC), first described by Hoare [9]. HEPSYCODE defines two system-level models, the SBM and the TL. The former is realized from the original HML. The latter contains all necessary and low-level hardware architectural details (e.g., PUs, MUs, CUs). Such models are supported by some C++ libraries that extend the standard SystemC library to implement CSP. The language of Communicating Sequential Processes (CSP) was developed for describing systems of interacting components and is supported by an underlying theory for reasoning about them.
	* TODO		CSP processes are modeled by using classic SC_THREAD while CSP channels have been modeled by introducing a proper sc_csp_channel as better described later. A “CSP SC_THREAD” presents an init section and an infinite loop behavior while accessing only its local variables and so communicating with other “CSP SC_THREAD” only by means of CSP channels. Finally, in a “CSP SC_THREAD”, only basic C/C++ statements and C++/SystemC data types are allowed while avoiding a full OOP approach since it could introduce critical issues for estimation and HW synthesis activities (in fact, the adopted restrictions have been inspired by [10]). Since the SBM is based on CSP, the SystemC library has been extended to properly model CSP channels with a sc_csp_channel class.
			HEPSYCODE supports the UML/MARTE modeling language for system modeling. The integration of UML/MARTE allows the designer to use one of the most used languages in the embedded systems industry [17]. Moreover, MARTE is a standard UML profile to represent quantitative non-functional properties (e.g., time, performance). This variant of HEPSYCODE provides several steps of verification and validation (V&V) intending to discover eventual design flaws before the implementation. The novelty lies in the adoption of formal models to check the satisfiability of non-functional requirements and estimate system properties.

	== Interoperability with other C4D tools ==		== Interoperability with other C4D tools ==
Line 59:		Line 59:

	[8] Frank Vahid and Tony Givargis. 2001. Embedded System Design: A Unified Hardware/Software Introduction. John Wiley & Sons, Inc.		[8] Frank Vahid and Tony Givargis. 2001. Embedded System Design: A Unified Hardware/Software Introduction. John Wiley & Sons, Inc.

			[9] Hoare C.A.R. (1978) Communicating Sequential Processes. In: Hansen P.B. (eds) The Origin of Concurrent Programming. Springer, New York, NY

			[10] “SystemC Synthesis Subset Language Reference Manual”, https://www.accellera.org/community/systemc

Univaq at 19:19, 22 September 2022

2022-09-22T19:19:50Z

← Older revision		Revision as of 19:19, 22 September 2022
Line 44:		Line 44:
	==References==		==References==

	[1] Xilinx Zynq ~~SoCfamily~~, http://www.xilinx.com		[1] Xilinx Zynq SoC family, http://www.xilinx.com

	[2] Intel/Altera Cyclone V family, http://www.intel.com		[2] Intel/Altera Cyclone V family, http://www.intel.com

	[3] J. Teich. Hardware/software ~~codesign~~: The past, the present, and predicting the future. Proceedings of the IEEE, 100(Special Centennial Issue):1411{1430, May 2012.		[3] J. Teich. Hardware/software co-design: The past, the present, and predicting the future. Proceedings of the IEEE, 100 (Special Centennial Issue):1411-1430, May 2012.

	[4] L. Pomante. “System-level design space exploration for dedicated heterogeneous multi-processor systems”. IEEE Int. Conf. on Application-specific Systems, Architectures and Processors, 2011.		[4] L. Pomante. “System-level design space exploration for dedicated heterogeneous multi-processor systems”. IEEE Int. Conf. on Application-specific Systems, Architectures, and Processors, 2011.

	[5] L. Pomante, D. Sciuto, F. Salice, W. Fornaciari, C. Brandolese. Affinity-Driven System Design Exploration for Heterogeneous Multiprocessor SoC. IEEE Transactions on Computers, vol. 55, no. 5, May 2006.		[5] L. Pomante, D. Sciuto, F. Salice, W. Fornaciari, C. Brandolese. Affinity-Driven System Design Exploration for Heterogeneous Multiprocessor SoC. IEEE Transactions on Computers, vol. 55, no. 5, May 2006.
Line 58:		Line 58:
	[7] Pomante, L., Muttillo, V., Santic, M., Serri, P. SystemC-based electronic system-level design space exploration environment for dedicated heterogeneous multi-processor systems. Microprocessors and Microsystems, 72, 2020		[7] Pomante, L., Muttillo, V., Santic, M., Serri, P. SystemC-based electronic system-level design space exploration environment for dedicated heterogeneous multi-processor systems. Microprocessors and Microsystems, 72, 2020

	[8] Frank Vahid and Tony Givargis. 2001. Embedded System Design: A Unified Hardware/Software Introduction. John Wiley & Sons, Inc		[8] Frank Vahid and Tony Givargis. 2001. Embedded System Design: A Unified Hardware/Software Introduction. John Wiley & Sons, Inc.

Univaq at 19:18, 22 September 2022

2022-09-22T19:18:35Z

← Older revision		Revision as of 19:18, 22 September 2022
Line 54:		Line 54:
	[5] L. Pomante, D. Sciuto, F. Salice, W. Fornaciari, C. Brandolese. Affinity-Driven System Design Exploration for Heterogeneous Multiprocessor SoC. IEEE Transactions on Computers, vol. 55, no. 5, May 2006.		[5] L. Pomante, D. Sciuto, F. Salice, W. Fornaciari, C. Brandolese. Affinity-Driven System Design Exploration for Heterogeneous Multiprocessor SoC. IEEE Transactions on Computers, vol. 55, no. 5, May 2006.

	[6] HEPSYCODE, ~~http~~://www.~~hespsycode~~.com.		[6] HEPSYCODE, https://www.hepsycode.com/.

	[7] Pomante, L., Muttillo, V., Santic, M., Serri, P. SystemC-based electronic system-level design space exploration environment for dedicated heterogeneous multi-processor systems. Microprocessors and Microsystems, 72, 2020		[7] Pomante, L., Muttillo, V., Santic, M., Serri, P. SystemC-based electronic system-level design space exploration environment for dedicated heterogeneous multi-processor systems. Microprocessors and Microsystems, 72, 2020

	[8] Frank Vahid and Tony Givargis. 2001. Embedded System Design: A Unified Hardware/Software Introduction. John Wiley & Sons, Inc		[8] Frank Vahid and Tony Givargis. 2001. Embedded System Design: A Unified Hardware/Software Introduction. John Wiley & Sons, Inc

Univaq at 19:17, 22 September 2022

2022-09-22T19:17:58Z

← Older revision		Revision as of 19:17, 22 September 2022
Line 20:		Line 20:
	\|}		\|}

	The increasing complexity of nowadays embedded digital systems, especially those based on advanced system-on-chip (SoC) that explicitly use heterogeneous parallel architectures to meet demanding timing performance and power consumption requirements, and their shorter time-to-market are radically changing standard industrial design methodologies. Traditional design approaches based on the independent design of HW / SW components are no longer sufficient to efficiently exploit sub-areas of such SoCs. For this reason, system-level HW/SW co-design methods, where designers can early check system-level constraints and evaluate tradeoffs between cost and performance, are becoming increasingly important. These methods are capable of guiding system-level activities using appropriate models, metrics, and tools, and assisting the designer in all those tasks normally entrusted only to his or her experience (e.g., HW / SW architecture definition and system-level HW /SW partitioning ). In this context, this repository presents a reference methodology for electronic system level (ESL) HW/SW co-design, called HEPSYCODE, targeting heterogeneous parallel embedded systems. It has been extended in C4D to meet mixed-criticality requirements and to be integrated into UML/MARTE specifications.		The increasing complexity of nowadays embedded digital systems, especially those based on advanced system-on-chip (SoC) that explicitly use heterogeneous parallel architectures (e.g., [1][2]) to meet demanding timing performance and power consumption requirements, and their shorter time-to-market are radically changing standard industrial design methodologies. Traditional design approaches based on the independent design of HW/SW components are no longer sufficient to efficiently exploit sub-areas of such SoCs. For this reason, system-level HW/SW co-design methods, where designers can early check system-level constraints and evaluate tradeoffs between cost and performance, are becoming increasingly important [3]. These methods are capable of guiding system-level activities using appropriate models, metrics, and tools, and assisting the designer in all those tasks normally entrusted only to his or her experience (e.g., HW / SW architecture definition and system-level HW /SW partitioning ). In this context, this repository presents a reference methodology for electronic system level (ESL) HW/SW co-design, called HEPSYCODE (e.g., [4][5][6][7]), targeting heterogeneous parallel embedded systems. It has been extended in C4D to meet mixed-criticality requirements and to be integrated into UML/MARTE specifications.

	== Detailed Description ==		== Detailed Description ==

	Figure below shows the reference ESL HW/SW co-design flow while its main steps are briefly described below by giving emphasis (red elements in Figure below) to the interactions with the HEPSIM2 simulator/analysis tool.		Figure below shows the reference ESL HW/SW co-design flow while its main steps are briefly described below by giving emphasis (red elements in Figure below) to the interactions with the HEPSIM2 simulator/analysis tool. More details about the whole methodology can be found in [4][5][6][7].

	[[File:wp6-17_1_01.png\|600px\|thumb\|frame\|center\| Reference ESL HW/SW Co-Design Flow]]		[[File:wp6-17_1_01.png\|600px\|thumb\|frame\|center\| Reference ESL HW/SW Co-Design Flow]]

	The entry point of the reference HW /SW co-design flow is the System Behaviour Model (SBM), which is based on a CSP -like MoC and described using SystemC. It is enriched by timing constraints (TCs) and reference inputs (RI). The first step of the reference flow, performed using HEPSIM2, is the functional simulation. It allows checking the correctness of the SBM with respect to RI. In the following steps, the reference ESL HW /SW co-design flow is supported by a Technologies Library (TL), which can be considered as a database that provides a characterization of all HW technologies used to define the so-called Basic Blocks (BBs) to build the final system. The TL contains information about available General-Purpose Processors (GPPs), Application Specific Processors (ASPs), Single Purpose Processors (SPPs), memory, and interconnects (i.e., physical links). The next step is co-analysis and co-estimation. During co-analysis, the SBM is analyzed to evaluate three metrics: affinity, communication, and concurrency. The first one represents how much a CSP process is suitable to be executed on a specific processor class (i.e., GPP, ASP, SPP). The second one is the evaluation of the number of bits that the various CSP process pairs exchanged over the corresponding CSP channels during simulation. The third refers to how many concurrencies have been found during the simulation in the activities of the CSP processes and CSP channels (it is evaluated using HEPSIM2 in a given configuration). Co-estimation is responsible for estimating timing, size, and load. Timing represents the time needed by each processor in the TL to execute an SBM statement. Size represents the number of bytes in RAM and ROM needed to store data and instructions for each CSP process implemented in SW. For the implementation of HW CSP processes, it is the number of mm2 (depending on the target HW technology, equivalent metrics such as Equivalent Gates, Look Up Table, etc. may be used) needed to implement processing, memory, and interconnect elements. Load represents the utilization percentage that each CSP process when implemented in SW, would impose on each GPP/ASP (used to define the BBs) to meet a timing constraint specified by the designer (i.e., it is actually a time to completion, TTC). After this step, the flow enters Design Space Exploration (DSE), which consists of 2 activities, "HW /SW Partitioning, Architecture Definition and Mapping" and "Timing HW /SW Co-simulation". The first activity is responsible for defining the HW architecture of the target system and for HW /SW partitioning and mapping processes and channels to available processors and physical connections. This data is then provided to HEPSIM2 to verify that the proposed architecture or mapping meets the timing constraints. Data exchange between the different steps of the entire ESL HW /SW co-design flow is supported by appropriate XML files.		The entry point of the reference HW /SW co-design flow is the System Behaviour Model (SBM), which is based on a CSP -like MoC and described using SystemC. It is enriched by timing constraints (TCs) and reference inputs (RI). The first step of the reference flow, performed using HEPSIM2, is the functional simulation. It allows checking the correctness of the SBM with respect to RI. In the following steps, the reference ESL HW /SW co-design flow is supported by a Technologies Library (TL), which can be considered as a database that provides a characterization of all HW technologies used to define the so-called Basic Blocks (BBs) to build the final system. The TL contains information about available General-Purpose Processors (GPPs), Application Specific Processors (ASPs), Single Purpose Processors (SPPs) [8], memory, and interconnects (i.e., physical links). The next step is co-analysis and co-estimation. During co-analysis, the SBM is analyzed to evaluate three metrics: affinity, communication, and concurrency. The first one represents how much a CSP process is suitable to be executed on a specific processor class (i.e., GPP, ASP, SPP) [5]. The second one is the evaluation of the number of bits that the various CSP process pairs exchanged over the corresponding CSP channels during simulation. The third refers to how many concurrencies have been found during the simulation in the activities of the CSP processes and CSP channels (it is evaluated using HEPSIM2 in a given configuration). Co-estimation is responsible for estimating timing, size, and load. Timing represents the time needed by each processor in the TL to execute an SBM statement. Size represents the number of bytes in RAM and ROM needed to store data and instructions for each CSP process implemented in SW. For the implementation of HW CSP processes, it is the number of mm2 (depending on the target HW technology, equivalent metrics such as Equivalent Gates, Look Up Table, etc. may be used) needed to implement processing, memory, and interconnect elements. Load represents the utilization percentage that each CSP process when implemented in SW, would impose on each GPP/ASP (used to define the BBs) to meet a timing constraint specified by the designer (i.e., it is actually a time to completion, TTC). After this step, the flow enters Design Space Exploration (DSE), which consists of 2 activities, "HW /SW Partitioning, Architecture Definition and Mapping" and "Timing HW /SW Co-simulation". The first activity is responsible for defining the HW architecture of the target system and for HW /SW partitioning and mapping processes and channels to available processors and physical connections. This data is then provided to HEPSIM2 to verify that the proposed architecture or mapping meets the timing constraints. Data exchange between the different steps of the entire ESL HW /SW co-design flow is supported by appropriate XML files.

	==Contribution and Improvements==		==Contribution and Improvements==
Line 42:		Line 42:
	[[File:wp6-17_1_02.png\|300px\|thumb\|frame\|center\| HEPSYCODE interoperability graph]]		[[File:wp6-17_1_02.png\|300px\|thumb\|frame\|center\| HEPSYCODE interoperability graph]]

	==~~Current Status~~==		==References==

	~~TODO~~		[1] Xilinx Zynq SoCfamily, http://www.xilinx.com

	~~==Design and Implementation==~~		[2] Intel/Altera Cyclone V family, http://www.intel.com

	~~TODO~~		[3] J. Teich. Hardware/software codesign: The past, the present, and predicting the future. Proceedings of the IEEE, 100(Special Centennial Issue):1411{1430, May 2012.

			[4] L. Pomante. “System-level design space exploration for dedicated heterogeneous multi-processor systems”. IEEE Int. Conf. on Application-specific Systems, Architectures and Processors, 2011.

			[5] L. Pomante, D. Sciuto, F. Salice, W. Fornaciari, C. Brandolese. Affinity-Driven System Design Exploration for Heterogeneous Multiprocessor SoC. IEEE Transactions on Computers, vol. 55, no. 5, May 2006.

			[6] HEPSYCODE, http://www.hespsycode.com.

			[7] Pomante, L., Muttillo, V., Santic, M., Serri, P. SystemC-based electronic system-level design space exploration environment for dedicated heterogeneous multi-processor systems. Microprocessors and Microsystems, 72, 2020

			[8] Frank Vahid and Tony Givargis. 2001. Embedded System Design: A Unified Hardware/Software Introduction. John Wiley & Sons, Inc