From cfa9ab377835911f23d9b0831c7be302ed1f58de Mon Sep 17 00:00:00 2001 From: petertorelli Date: Tue, 22 May 2018 17:54:08 -0700 Subject: [PATCH] Uploaded to GitHub --- LICENSE.md | 44 ++ Makefile | 141 ++++ README.md | 393 ++++++++++ barebones/core_portme.c | 118 +++ barebones/core_portme.h | 188 +++++ barebones/core_portme.mak | 71 ++ barebones/cvt.c | 102 +++ barebones/ee_printf.c | 614 +++++++++++++++ core_list_join.c | 496 ++++++++++++ core_main.c | 356 +++++++++ core_matrix.c | 308 ++++++++ core_state.c | 277 +++++++ core_util.c | 210 ++++++ coremark.h | 174 +++++ cygwin/core_portme.c | 325 ++++++++ cygwin/core_portme.h | 281 +++++++ cygwin/core_portme.mak | 125 +++ docs/READM.md | 1 + docs/balance_O0_joined.png | Bin 0 -> 48672 bytes docs/coremark_profile_o0_joined.png | Bin 0 -> 212004 bytes docs/html/files/PIC32/core_portme-mak.html | 68 ++ docs/html/files/core_list_join-c.html | 58 ++ docs/html/files/core_main-c.html | 42 ++ docs/html/files/core_matrix-c.html | 56 ++ docs/html/files/core_state-c.html | 46 ++ docs/html/files/core_util-c.html | 42 ++ docs/html/files/coremark-h.html | 46 ++ docs/html/files/docs/core_state.png | Bin 0 -> 72093 bytes docs/html/files/linux/core_portme-c.html | 58 ++ docs/html/files/linux/core_portme-h.html | 72 ++ docs/html/files/linux/core_portme-mak.html | 76 ++ docs/html/files/readme-txt.html | 71 ++ docs/html/files/release_notes-txt.html | 56 ++ docs/html/index.html | 1 + docs/html/index/BuildTargets.html | 31 + docs/html/index/Configuration.html | 51 ++ docs/html/index/Configurations.html | 45 ++ docs/html/index/Files.html | 35 + docs/html/index/Functions.html | 55 ++ docs/html/index/General.html | 75 ++ docs/html/index/General2.html | 47 ++ docs/html/index/Types.html | 31 + docs/html/index/Variables.html | 55 ++ docs/html/javascript/main.js | 836 +++++++++++++++++++++ docs/html/javascript/searchdata.js | 212 ++++++ docs/html/search/BuildTargetsP.html | 18 + docs/html/search/ConfigurationC.html | 18 + docs/html/search/ConfigurationH.html | 18 + docs/html/search/ConfigurationM.html | 18 + docs/html/search/ConfigurationS.html | 18 + docs/html/search/ConfigurationT.html | 18 + docs/html/search/ConfigurationU.html | 18 + docs/html/search/ConfigurationsH.html | 20 + docs/html/search/ConfigurationsM.html | 20 + docs/html/search/ConfigurationsS.html | 20 + docs/html/search/ConfigurationsT.html | 20 + docs/html/search/FilesC.html | 18 + docs/html/search/FilesR.html | 18 + docs/html/search/FunctionsC.html | 18 + docs/html/search/FunctionsG.html | 18 + docs/html/search/FunctionsI.html | 18 + docs/html/search/FunctionsM.html | 18 + docs/html/search/FunctionsP.html | 18 + docs/html/search/FunctionsS.html | 18 + docs/html/search/FunctionsT.html | 18 + docs/html/search/GeneralB.html | 18 + docs/html/search/GeneralC.html | 18 + docs/html/search/GeneralD.html | 18 + docs/html/search/GeneralF.html | 18 + docs/html/search/GeneralG.html | 18 + docs/html/search/GeneralH.html | 18 + docs/html/search/GeneralI.html | 18 + docs/html/search/GeneralL.html | 18 + docs/html/search/GeneralM.html | 18 + docs/html/search/GeneralO.html | 18 + docs/html/search/GeneralP.html | 18 + docs/html/search/GeneralR.html | 18 + docs/html/search/GeneralS.html | 18 + docs/html/search/GeneralT.html | 18 + docs/html/search/GeneralU.html | 18 + docs/html/search/GeneralV.html | 18 + docs/html/search/GeneralW.html | 18 + docs/html/search/NoResults.html | 13 + docs/html/search/TypesS.html | 18 + docs/html/search/VariablesC.html | 18 + docs/html/search/VariablesD.html | 18 + docs/html/search/VariablesL.html | 18 + docs/html/search/VariablesO.html | 18 + docs/html/search/VariablesP.html | 18 + docs/html/search/VariablesR.html | 18 + docs/html/search/VariablesS.html | 18 + docs/html/styles/1.css | 767 +++++++++++++++++++ docs/html/styles/2.css | 6 + docs/html/styles/main.css | 2 + linux/core_portme.c | 327 ++++++++ linux/core_portme.h | 281 +++++++ linux/core_portme.mak | 124 +++ linux64/core_portme.c | 325 ++++++++ linux64/core_portme.h | 279 +++++++ linux64/core_portme.mak | 124 +++ simple/core_portme.c | 117 +++ simple/core_portme.h | 184 +++++ simple/core_portme.mak | 44 ++ 103 files changed, 9800 insertions(+) create mode 100644 LICENSE.md create mode 100644 Makefile create mode 100644 README.md create mode 100755 barebones/core_portme.c create mode 100755 barebones/core_portme.h create mode 100755 barebones/core_portme.mak create mode 100755 barebones/cvt.c create mode 100755 barebones/ee_printf.c create mode 100644 core_list_join.c create mode 100644 core_main.c create mode 100644 core_matrix.c create mode 100644 core_state.c create mode 100644 core_util.c create mode 100644 coremark.h create mode 100755 cygwin/core_portme.c create mode 100755 cygwin/core_portme.h create mode 100755 cygwin/core_portme.mak create mode 100644 docs/READM.md create mode 100644 docs/balance_O0_joined.png create mode 100644 docs/coremark_profile_o0_joined.png create mode 100644 docs/html/files/PIC32/core_portme-mak.html create mode 100644 docs/html/files/core_list_join-c.html create mode 100644 docs/html/files/core_main-c.html create mode 100644 docs/html/files/core_matrix-c.html create mode 100644 docs/html/files/core_state-c.html create mode 100644 docs/html/files/core_util-c.html create mode 100644 docs/html/files/coremark-h.html create mode 100644 docs/html/files/docs/core_state.png create mode 100644 docs/html/files/linux/core_portme-c.html create mode 100644 docs/html/files/linux/core_portme-h.html create mode 100644 docs/html/files/linux/core_portme-mak.html create mode 100644 docs/html/files/readme-txt.html create mode 100644 docs/html/files/release_notes-txt.html create mode 100644 docs/html/index.html create mode 100644 docs/html/index/BuildTargets.html create mode 100644 docs/html/index/Configuration.html create mode 100644 docs/html/index/Configurations.html create mode 100644 docs/html/index/Files.html create mode 100644 docs/html/index/Functions.html create mode 100644 docs/html/index/General.html create mode 100644 docs/html/index/General2.html create mode 100644 docs/html/index/Types.html create mode 100644 docs/html/index/Variables.html create mode 100644 docs/html/javascript/main.js create mode 100644 docs/html/javascript/searchdata.js create mode 100644 docs/html/search/BuildTargetsP.html create mode 100644 docs/html/search/ConfigurationC.html create mode 100644 docs/html/search/ConfigurationH.html create mode 100644 docs/html/search/ConfigurationM.html create mode 100644 docs/html/search/ConfigurationS.html create mode 100644 docs/html/search/ConfigurationT.html create mode 100644 docs/html/search/ConfigurationU.html create mode 100644 docs/html/search/ConfigurationsH.html create mode 100644 docs/html/search/ConfigurationsM.html create mode 100644 docs/html/search/ConfigurationsS.html create mode 100644 docs/html/search/ConfigurationsT.html create mode 100644 docs/html/search/FilesC.html create mode 100644 docs/html/search/FilesR.html create mode 100644 docs/html/search/FunctionsC.html create mode 100644 docs/html/search/FunctionsG.html create mode 100644 docs/html/search/FunctionsI.html create mode 100644 docs/html/search/FunctionsM.html create mode 100644 docs/html/search/FunctionsP.html create mode 100644 docs/html/search/FunctionsS.html create mode 100644 docs/html/search/FunctionsT.html create mode 100644 docs/html/search/GeneralB.html create mode 100644 docs/html/search/GeneralC.html create mode 100644 docs/html/search/GeneralD.html create mode 100644 docs/html/search/GeneralF.html create mode 100644 docs/html/search/GeneralG.html create mode 100644 docs/html/search/GeneralH.html create mode 100644 docs/html/search/GeneralI.html create mode 100644 docs/html/search/GeneralL.html create mode 100644 docs/html/search/GeneralM.html create mode 100644 docs/html/search/GeneralO.html create mode 100644 docs/html/search/GeneralP.html create mode 100644 docs/html/search/GeneralR.html create mode 100644 docs/html/search/GeneralS.html create mode 100644 docs/html/search/GeneralT.html create mode 100644 docs/html/search/GeneralU.html create mode 100644 docs/html/search/GeneralV.html create mode 100644 docs/html/search/GeneralW.html create mode 100644 docs/html/search/NoResults.html create mode 100644 docs/html/search/TypesS.html create mode 100644 docs/html/search/VariablesC.html create mode 100644 docs/html/search/VariablesD.html create mode 100644 docs/html/search/VariablesL.html create mode 100644 docs/html/search/VariablesO.html create mode 100644 docs/html/search/VariablesP.html create mode 100644 docs/html/search/VariablesR.html create mode 100644 docs/html/search/VariablesS.html create mode 100644 docs/html/styles/1.css create mode 100644 docs/html/styles/2.css create mode 100644 docs/html/styles/main.css create mode 100755 linux/core_portme.c create mode 100755 linux/core_portme.h create mode 100755 linux/core_portme.mak create mode 100755 linux64/core_portme.c create mode 100755 linux64/core_portme.h create mode 100755 linux64/core_portme.mak create mode 100755 simple/core_portme.c create mode 100755 simple/core_portme.h create mode 100755 simple/core_portme.mak diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 index 0000000..a5bb3e4 --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,44 @@ +# COREMARK® ACCEPTABLE USE AGREEMENT + +This ACCEPTABLE USE AGREEMENT (this “Agreement”) is offered by Embedded Microprocessor Benchmark Consortium, a California nonprofit corporation (“Licensor”), to users of its CoreMark® software (“Licensee”) exclusively on the following terms. + +Licensor offers benchmarking software (“Software”) pursuant to an open source license, but carefully controls use of its benchmarks and their associated goodwill. Licensor has registered its trademark in one of the benchmarks available through the Software, COREMARK, Ser. No. 85/487,290; Reg. No. 4,179,307 (the “Trademark”), and promotes the use of a standard metric as a benchmark for assessing the performance of embedded systems. Solely on the terms described herein, Licensee may use and display the Trademark in connection with the generation of data regarding measurement and analysis of computer and embedded system benchmarking via the Software (the “Licensed Use”). + +## Article 1 – License Grant. +1.1. License. Subject to the terms and conditions of this Agreement, Licensor hereby grants to Licensee, and Licensee hereby accepts from Licensor, a personal, non-exclusive, royalty-free, revocable right and license to use and display the Trademark during the term of this Agreement (the “Term”), solely and exclusively in connection with the Licensed Use. During the Term, Licensee (i) shall not modify or otherwise create derivative works of the Trademark, and (ii) may use the Trademark only to the extent permitted under this License. Neither Licensee nor any affiliate or agent thereof shall otherwise use the Trademark without the prior express written consent of Licensor, which may be withheld in its sole and absolute discretion. All rights not expressly granted to Licensee hereunder shall remain the exclusive property of Licensor. + +1.2. Modifications to the Software. Licensee shall not use the Trademark in connection with any use of a modified, derivative, or otherwise altered copy of the Software. + +1.3. Licensor’s Use. Nothing in this Agreement shall preclude Licensor or any of its successors or assigns from using or permitting other entities to use the Trademark, whether or not such entity directly or indirectly competes or conflicts with Licensee’s Licensed Use in any manner. + +1.4. Term and Termination. This Agreement is perpetual unless terminated by either of the parties. Licensee may terminate this Agreement for convenience, without cause or liability, for any reason or for no reason whatsoever, upon ten (10) business days written notice. Licensor may terminate this Agreement effective immediately upon notice of breach. Upon termination, Licensee shall immediately remove all implementations of the Trademark from the Licensed Use, and delete all digitals files and records of all materials related to the Trademark. + +## Article 2 – Ownership. +2.1. Ownership. Licensee acknowledges and agrees that Licensor is the owner of all right, title, and interest in and to the Trademark, and all such right, title, and interest shall remain with Licensor. Licensee shall not contest, dispute, challenge, oppose, or seek to cancel Licensor’s right, title, and interest in and to the Trademark. Licensee shall not prosecute any application for registration of the Trademark. Licensee shall display appropriate notices regarding ownership of the Trademark in connection with the Licensed Use. + +2.2. Goodwill. Licensee acknowledges that Licensee shall not acquire any right, title, or interest in the Trademark by virtue of this Agreement other than the license granted hereunder, and disclaims any such right, title, interest, or ownership. All goodwill and reputation generated by Licensee’s use of the Trademark shall inure to the exclusive benefit of Licensor. Licensee shall not by any act or omission use the Trademark in any manner that disparages or reflects adversely on Licensor or its Licensed Use or reputation. Licensee shall not take any action that would interfere with or prejudice Licensor’s ownership or registration of the Trademark, the validity of the Trademark or the validity of the license granted by this Agreement. If Licensor determines and notifies Licensee that any act taken in connection with the Licensed Use (i) is inaccurate, unlawful or offensive to good taste; (ii) fails to provide for proper trademark notices, or (iii) otherwise violates Licensee’s obligations under this Agreement, the license granted under this Agreement shall terminate. + +## Article 3 – Indemnification. +3.1. Indemnification Generally. Licensee agrees to indemnify, defend, and hold harmless (collectively “indemnify” or “indemnification”) Licensor, including Licensor’s members, managers, officers, and employees (collectively “Related Persons”), from and against, and pay or reimburse Licensor and such Related Persons for, any and all third-party actions, claims, demands, proceedings, investigations, inquiries (collectively, “Claims”), and any and all liabilities, obligations, fines, deficiencies, costs, expenses, royalties, losses, and damages (including reasonable outside counsel fees and expenses) associated with such Claims, to the extent that such Claim arises out of (i) Licensee’s material breach of this Agreement, or (ii) any allegation(s) that Licensee’s actions infringe or violate any third-party intellectual property right, including without limitation, any U.S. copyright, patent, or trademark, or are otherwise found to be tortious or criminal (whether or not such indemnified person is a named party in a legal proceeding). + +3.2. Notice and Defense of Claims. Licensor shall promptly notify Licensee of any Claim for which indemnification is sought, following actual knowledge of such Claim, provided however that the failure to give such notice shall not relieve Licensee of its obligations hereunder except to the extent that Licensee is materially prejudiced by such failure. In the event that any third-party Claim is brought, Licensee shall have the right and option to undertake and control the defense of such action with counsel of its choice, provided however that (i) Licensor at its own expense may participate and appear on an equal footing with Licensee in the defense of any such Claim, (ii) Licensor may undertake and control such defense in the event of the material failure of Licensee to undertake and control the same; and (iii) the defense of any Claim relating to the intellectual property rights of Licensor or its licensors and any related counterclaims shall be solely controlled by Licensor with counsel of its choice. Licensee shall not consent to judgment or concede or settle or compromise any Claim without the prior written approval of Licensor (whose approval shall not be unreasonably withheld), unless such concession or settlement or compromise includes a full and unconditional release of Licensor and any applicable Related Persons from all liabilities in respect of such Claim. + +## Article 4 – Miscellaneous. +4.1. Relationship of the Parties. This Agreement does not create a partnership, franchise, joint venture, agency, fiduciary, or employment relationship between the parties. + +4.2. No Third-Party Beneficiaries. Except for the rights of Related Persons under Article 3 (Indemnification), there are no third-party beneficiaries to this Agreement. + +4.3. Assignment. Licensee’s rights hereunder are non-assignable, and may not be sublicensed. + +4.4. Equitable Relief. Licensee acknowledges that the remedies available at law for any breach of this Agreement will, by their nature, be inadequate. Accordingly, Licensor may obtain injunctive relief or other equitable relief to restrain a breach or threatened breach of this Agreement or to specifically enforce this Agreement, without proving that any monetary damages have been sustained, and without the requirement of posting of a bond prior to obtaining such equitable relief. + +4.5. Governing Law. This Agreement will be interpreted, construed, and enforced in all respects in accordance with the laws of the State of California, without reference to its conflict of law principles. + +4.6. Attorneys’ Fees. If any legal action, arbitration or other proceeding is brought for the enforcement of this Agreement, or because of an alleged dispute, breach, default, or misrepresentation in connection with any of the provisions of this Agreement, the successful or prevailing party shall be entitled to recover its reasonable attorneys’ fees and other reasonable costs incurred in that action or proceeding, in addition to any other relief to which it may be entitled. + +4.7. Amendment; Waiver. This Agreement may not be amended, nor may any rights under it be waived, except in writing by Licensor. + +4.8. Severability. If any provision of this Agreement is held by a court of competent jurisdiction to be contrary to law, the provision shall be modified by the court and interpreted so as best to accomplish the objectives of the original provision to the fullest extent +permitted by law, and the remaining provisions of this Agreement shall remain in effect. + +4.9. Entire Agreement. This Agreement constitutes the entire agreement between the parties and supersedes all prior and contemporaneous agreements, proposals or representations, written or oral, concerning its subject matter. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..0c97a94 --- /dev/null +++ b/Makefile @@ -0,0 +1,141 @@ +#Author : Shay Gal-On, EEMBC +# +#This file is part of EEMBC(R) and CoreMark(TM), which are Copyright (C) 2009 +#All rights reserved. +# +#EEMBC CoreMark Software is a product of EEMBC and is provided under the terms of the +#CoreMark License that is distributed with the official EEMBC COREMARK Software release. +#If you received this EEMBC CoreMark Software without the accompanying CoreMark License, +#you must discontinue use and download the official release from www.coremark.org. +# +#Also, if you are publicly displaying scores generated from the EEMBC CoreMark software, +#make sure that you are in compliance with Run and Reporting rules specified in the accompanying readme.txt file. +# +#EEMBC +#4354 Town Center Blvd. Suite 114-200 +#El Dorado Hills, CA, 95762 + + +# Make sure the default target is to simply build and run the benchmark. +RSTAMP = v1.0 + +.PHONY: run score +run: $(OUTFILE) rerun score + +score: + @echo "Check run1.log and run2.log for results." + @echo "See readme.txt for run and reporting rules." + +ifndef PORT_DIR +# Ports for a couple of common self hosted platforms +UNAME=$(shell if [[ `uname 2> /dev/null` ]] ; then uname ; fi) +ifneq (,$(findstring CYGWIN,$(UNAME))) +PORT_DIR=cygwin +endif +ifneq (,$(findstring Linux,$(UNAME))) +MACHINE=$(shell uname -m) +ifneq (,$(findstring 64,$(MACHINE))) +PORT_DIR=linux64 +else +PORT_DIR=linux +endif +endif +endif +ifndef PORT_DIR +$(error PLEASE define PORT_DIR! (e.g. make PORT_DIR=simple)) +endif +vpath %.c $(PORT_DIR) +vpath %.h $(PORT_DIR) +vpath %.mak $(PORT_DIR) +include $(PORT_DIR)/core_portme.mak + +ifndef $(ITERATIONS) +ITERATIONS=0 +endif +ifdef REBUILD +FORCE_REBUILD=force_rebuild +endif + +CFLAGS += -DITERATIONS=$(ITERATIONS) + +CORE_FILES = core_list_join core_main core_matrix core_state core_util +ORIG_SRCS = $(addsuffix .c,$(CORE_FILES)) +SRCS = $(ORIG_SRCS) $(PORT_SRCS) +OBJS = $(addprefix $(OPATH),$(addsuffix $(OEXT),$(CORE_FILES)) $(PORT_OBJS)) +OUTNAME = coremark$(EXE) +OUTFILE = $(OPATH)$(OUTNAME) +LOUTCMD = $(OFLAG) $(OUTFILE) $(LFLAGS_END) +OUTCMD = $(OUTFLAG) $(OUTFILE) $(LFLAGS_END) + +HEADERS = coremark.h +CHECK_FILES = $(ORIG_SRCS) $(HEADERS) + +$(OPATH): + $(MKDIR) $(OPATH) + +.PHONY: compile link +ifdef SEPARATE_COMPILE +$(OPATH)$(PORT_DIR): + $(MKDIR) $(OPATH)$(PORT_DIR) + +compile: $(OPATH) $(OPATH)$(PORT_DIR) $(OBJS) $(HEADERS) +link: compile + $(LD) $(LFLAGS) $(XLFLAGS) $(OBJS) $(LOUTCMD) + +else + +compile: $(OPATH) $(SRCS) $(HEADERS) + $(CC) $(CFLAGS) $(XCFLAGS) $(SRCS) $(OUTCMD) +link: compile + @echo "Link performed along with compile" + +endif + +$(OUTFILE): $(SRCS) $(HEADERS) Makefile core_portme.mak $(FORCE_REBUILD) + $(MAKE) port_prebuild + $(MAKE) link + $(MAKE) port_postbuild + +.PHONY: rerun +rerun: + $(MAKE) XCFLAGS="$(XCFLAGS) -DPERFORMANCE_RUN=1" load run1.log + $(MAKE) XCFLAGS="$(XCFLAGS) -DVALIDATION_RUN=1" load run2.log + +PARAM1=$(PORT_PARAMS) 0x0 0x0 0x66 $(ITERATIONS) +PARAM2=$(PORT_PARAMS) 0x3415 0x3415 0x66 $(ITERATIONS) +PARAM3=$(PORT_PARAMS) 8 8 8 $(ITERATIONS) + +run1.log-PARAM=$(PARAM1) 7 1 2000 +run2.log-PARAM=$(PARAM2) 7 1 2000 +run3.log-PARAM=$(PARAM3) 7 1 1200 + +run1.log run2.log run3.log: load + $(MAKE) port_prerun + $(RUN) $(OUTFILE) $($(@)-PARAM) > $(OPATH)$@ + $(MAKE) port_postrun + +.PHONY: gen_pgo_data +gen_pgo_data: run3.log + +.PHONY: load +load: $(OUTFILE) + $(MAKE) port_preload + $(LOAD) $(OUTFILE) + $(MAKE) port_postload + +.PHONY: clean +clean: + rm -f $(OUTFILE) $(OPATH)*.log *.info $(OPATH)index.html $(PORT_CLEAN) + +.PHONY: force_rebuild +force_rebuild: + echo "Forcing Rebuild" + +.PHONY: check +check: + md5sum -c coremark.md5 + +ifdef ETC +# Targets related to testing and releasing CoreMark. Not part of the general release! +include Makefile.internal +endif diff --git a/README.md b/README.md new file mode 100644 index 0000000..d68c3bc --- /dev/null +++ b/README.md @@ -0,0 +1,393 @@ + +# Introduction + +CoreMark's primary goals are simplicity and providing a method for testing only a processor's core features. For more information about EEMBC's comprehensive embedded benchmark suites, please see www.eembc.org. + +# Building and Running + +To build and run the benchmark, type + +`> make` + +Full results are available in the files `run1.log` and `run2.log`. CoreMark result can be found in `run1.log`. + +## Cross Compiling + +For cross compile platforms please adjust `core_portme.mak`, `core_portme.h` (and possibly `core_portme.c`) according to the specific platform used. When porting to a new platform, it is recommended to copy one of the default port folders (e.g. `mkdir && cp linux/* `), adjust the porting files, and run: +~~~ +% make PORT_DIR= +~~~ + +## Make Targets +`run` - Default target, creates `run1.log` and `run2.log`. +`run1.log` - Run the benchmark with performance parameters, and output to `run1.log` +`run2.log` - Run the benchmark with validation parameters, and output to `run2.log` +`run3.log` - Run the benchmark with profile generation parameters, and output to `run3.log` +`compile` - compile the benchmark executable +`link` - link the benchmark executable +`check` - test MD5 of sources that may not be modified +`clean` - clean temporary files + +### Make flag: `ITERATIONS` +By default, the benchmark will run between 10-100 seconds. To override, use `ITERATIONS=N` +~~~ +% make ITERATIONS=10 +~~~ +Will run the benchmark for 10 iterations. It is recommended to set a specific number of iterations in certain situations e.g.: + +* Running with a simulator +* Measuring power/energy +* Timing cannot be restarted + +Minimum required run time: **Results are only valid for reporting if the benchmark ran for at least 10 secs!** + +### Make flag: `XCFLAGS` +To add compiler flags from the command line, use `XCFLAGS` e.g.: + +~~~ +% make XCFLAGS="-g -DMULTITHREAD=4 -DUSE_FORK=1" +~~~ + +### Make flag: `CORE_DEBUG` + +Define to compile for a debug run if you get incorrect CRC. + +~~~ +% make XCFLAGS="-DCORE_DEBUG=1" +~~~ + +### Make flag: `REBUILD` + +Force a rebuild of the executable. + +## Systems Without `make` +The following files need to be compiled: +* `core_list_join.c` +* `core_main.c` +* `core_matrix.c` +* `core_state.c` +* `core_util.c` +* `PORT_DIR/core_portme.c` + +For example: +~~~ +% gcc -O2 -o coremark.exe core_list_join.c core_main.c core_matrix.c core_state.c core_util.c simple/core_portme.c -DPERFORMANCE_RUN=1 -DITERATIONS=1000 +% ./coremark.exe > run1.log +~~~ +The above will compile the benchmark for a performance run and 1000 iterations. Output is redirected to `run1.log`. + +# Parallel Execution +Use `XCFLAGS=-DMULTITHREAD=N` where N is number of threads to run in parallel. Several implementations are available to execute in multiple contexts, or you can implement your own in `core_portme.c`. + +~~~ +% make XCFLAGS="-DMULTITHREAD=4 -DUSE_PTHREAD" +~~~ + +Above will compile the benchmark for execution on 4 cores, using POSIX Threads API. + +# Run Parameters for the Benchmark Executable +CoreMark's executable takes several parameters as follows (but only if `main()` accepts arguments): +1st - A seed value used for initialization of data. +2nd - A seed value used for initialization of data. +3rd - A seed value used for initialization of data. +4th - Number of iterations (0 for auto : default value) +5th - Reserved for internal use. +6th - Reserved for internal use. +7th - For malloc users only, ovreride the size of the input data buffer. + +The run target from make will run coremark with 2 different data initialization seeds. + +## Alternative parameters: +If not using `malloc` or command line arguments are not supported, the buffer size +for the algorithms must be defined via the compiler define `TOTAL_DATA_SIZE`. +`TOTAL_DATA_SIZE` must be set to 2000 bytes (default) for standard runs. +The default for such a target when testing different configurations could be: + +~~~ +% make XCFLAGS="-DTOTAL_DATA_SIZE=6000 -DMAIN_HAS_NOARGC=1" +~~~ + +# Submitting Results + +CoreMark results can be submitted on the web. Open a web browser and go to http://www.coremark.org/benchmark/index.php?pg=benchmark. Select the link to add a new score and follow the instructions. + +# Run Rules +What is and is not allowed. + +## Required +1. The benchmark needs to run for at least 10 seconds. +2. All validation must succeed for seeds `0,0,0x66` and `0x3415,0x3415,0x66`, buffer size of 2000 bytes total. + * If not using command line arguments to main: +~~~ + % make XCFLAGS="-DPERFORMANCE_RUN=1" REBUILD=1 run1.log + % make XCFLAGS="-DVALIDATION_RUN=1" REBUILD=1 run2.log +~~~ +3. If using profile guided optimization, profile must be generated using seeds of `8,8,8`, and buffer size of 1200 bytes total. +~~~ + % make XCFLAGS="-DTOTAL_DATA_SIZE=1200 -DPROFILE_RUN=1" REBUILD=1 run3.log +~~~ +4. All source files must be compiled with the same flags. +5. All data type sizes must match size in bits such that: + * `ee_u8` is an 8 bits datatype. + * `ee_s16` is a 16 bits datatype. + * `ee_u16` is a 16 bits datatype. + * `ee_s32` is a 32 bits datatype. + * `ee_u32` is a 32 bits datatype. + +## Allowed + +1. Changing number of iterations +2. Changing toolchain and build/load/run options +3. Changing method of acquiring a data memory block +5. Changing the method of acquiring seed values +6. Changing implementation `in core_portme.c` +7. Changing configuration values in `core_portme.h` +8. Changing `core_portme.mak` + +## NOT ALLOWED +1. Changing of source file other then `core_portme*` (use `make check` to validate) + +# Reporting rules +Use the following syntax to report results on a data sheet: + +CoreMark 1.0 : N / C [/ P] [/ M] + +N - Number of iterations per second with seeds 0,0,0x66,size=2000) + +C - Compiler version and flags + +P - Parameters such as data and code allocation specifics + +* This parameter *may* be omitted if all data was allocated on the heap in RAM. +* This parameter *may not* be omitted when reporting CoreMark/MHz + +M - Type of parallel execution (if used) and number of contexts +* This parameter may be omitted if parallel execution was not used. + +e.g.: + +~~~ +CoreMark 1.0 : 128 / GCC 4.1.2 -O2 -fprofile-use / Heap in TCRAM / FORK:2 +~~~ +or +~~~ +CoreMark 1.0 : 1400 / GCC 3.4 -O4 +~~~ + +If reporting scaling results, the results must be reported as follows: + +CoreMark/MHz 1.0 : N / C / P [/ M] + +P - When reporting scaling results, memory parameter must also indicate memory frequency:core frequency ratio. +1. If the core has cache and cache frequency to core frequency ratio is configurable, that must also be included. + +e.g.: + +~~~ +CoreMark/MHz 1.0 : 1.47 / GCC 4.1.2 -O2 / DDR3(Heap) 30:1 Memory 1:1 Cache +~~~ + +# Log File Format +The log files have the following format + +~~~ +2K performance run parameters for coremark. (Run type) +CoreMark Size : 666 (Buffer size) +Total ticks : 25875 (platform dependent value) +Total time (secs) : 25.875000 (actual time in seconds) +Iterations/Sec : 3864.734300 (Performance value to report) +Iterations : 100000 (number of iterations used) +Compiler version : GCC3.4.4 (Compiler and version) +Compiler flags : -O2 (Compiler and linker flags) +Memory location : Code in flash, data in on chip RAM +seedcrc : 0xe9f5 (identifier for the input seeds) +[0]crclist : 0xe714 (validation for list part) +[0]crcmatrix : 0x1fd7 (validation for matrix part) +[0]crcstate : 0x8e3a (validation for state part) +[0]crcfinal : 0x33ff (iteration dependent output) +Correct operation validated. See readme.txt for run and reporting rules. (*Only when run is successful*) +CoreMark 1.0 : 6508.490622 / GCC3.4.4 -O2 / Heap (*Only on a successful performance run*) +~~~ + +# Theory of Operation + +This section describes the initial goals of CoreMark and their implementation. + +## Small and easy to understand + +* X number of source code lines for timed portion of the benchmark. +* Meaningful names for variables and functions. +* Comments for each block of code more than 10 lines long. + +## Portability + +A thin abstraction layer will be provided for I/O and timing in a separate file. All I/O and timing of the benchmark will be done through this layer. + +### Code / data size + +* Compile with gcc on x86 and make sure all sizes are according to requirements. +* If dynamic memory allocation is used, take total memory allocated into account as well. +* Avoid recursive functions and keep track of stack usage. +* Use the same memory block as data site for all algorithms, and initialize the data before each algorithm – while this means that initialization with data happens during the timed portion, it will only happen once during the timed portion and so have negligible effect on the results. + +## Controlled output + +This may be the most difficult goal. Compilers are constantly improving and getting better at analyzing code. To create work that cannot be computed at compile time and must be computed at run time, we will rely on two assumptions: + +* Some system functions (e.g. time, scanf) and parameters cannot be computed at compile time. In most cases, marking a variable volatile means the compiler is force to read this variable every time it is read. This will be used to introduce a factor into the input that cannot be precomputed at compile time. Since the results are input dependent, that will make sure that computation has to happen at run time. + +* Either a system function or I/O (e.g. scanf) or command line parameters or volatile variables will be used before the timed portion to generate data which is not available at compile time. Specific method used is not relevant as long as it can be controlled, and that it cannot be computed or eliminated by the compiler at compile time. E.g. if the clock() functions is a compiler stub, it may not be used. The derived values will be reported on the output so that verification can be done on a different machine. + +* We cannot rely on command line parameters since some embedded systems do not have the capability to provide command line parameters. All 3 methods above will be implemented (time based, scanf and command line parameters) and all 3 are valid if the compiler cannot determine the value at compile time. + +* It is important to note that The actual values that are to be supplied at run time will be standardized. The methodology is not intended to provide random data, but simply to provide controlled data that cannot be precomputed at compile time. + +* Printed results must be valid at run time. This will be used to make sure the computation has been executed. + +* Some embedded systems do not provide “printf” or other I/O functionality. All I/O will be done through a thin abstraction interface to allow execution on such systems (e.g. allow output via JTAG). + +## Key Algorithms + +### Linked List + +The following linked list structure will be used: + +~~~ +typedef struct list_data_s { + ee_s16 data16; + ee_s16 idx; +} list_data; + +typedef struct list_head_s { + struct list_head_s *next; + struct list_data_s *info; +} list_head; +~~~ + +While adding a level of indirection accessing the data, this structure is realistic and used in many embedded applications for small to medium lists. + +The list itself will be initialized on a block of memory that will be passed in to the initialization function. While in general linked lists use malloc for new nodes, embedded applications sometime control the memory for small data structures such as arrays and lists directly to avoid the overhead of system calls, so this approach is realistic. + +The linked list will be initialized such that 1/4 of the list pointers point to sequential areas in memory, and 3.4 of the list pointers are distributed in a non sequential manner. This is done to emulate a linked list that had add/remove happen for a while disrupting the neat order, and then a series of adds that are likely to come from sequential memory locations. + +For the benchmark itself: +- Multiple find operations are going to be performed. These find operations may result in the whole list being traversed. The result of each find will become part of the output chain. +- The list will be sorted using merge sort based on the data16 value, and then derive CRC of the data16 item in order for part of the list. The CRC will become part of the output chain. +- The list will be sorted again using merge sort based on the idx value. This sort will guarantee that the list is returned to the primary state before leaving the function, so that multiple iterations of the function will have the same result. CRC of the data16 for part of the list will again be calculated and become part of the output chain. + +The actual `data16` in each cell will be pseudo random based on a single 16b input that cannot be determined at compile time. In addition, the part of the list which is used for CRC will also be passed to the function, and determined based on an input that cannot be determined at run time. + +### Matrix Multiply + +This very simple algorithm forms the basis of many more complex algorithms. The tight inner loop is the focus of many optimizations (compiler as well as hardware based) and is thus relevant for embedded processing. + +The total available data space will be divided to 3 parts: +1. NxN matrix A. +2. NxN matrix B. +3. NxN matrix C. + +E.g. for 2K we will have 3 12x12 matrices (assuming data type of 32b 12(len)*12(wid)*4(size)*3(num) =1728 bytes). + +Matrix A will be initialized with small values (upper 3/4 of the bits all zero). +Matrix B will be initialized with medium values (upper half of the bits all zero). +Matrix C will be used for the result. + +For the benchmark itself: +- Multiple A by a constant into C, add the upper bits of each of the values in the result matrix. The result will become part of the output chain. +- Multiple A by column X of B into C, add the upper bits of each of the values in the result matrix. The result will become part of the output chain. +- Multiple A by B into C, add the upper bits of each of the values in the result matrix. The result will become part of the output chain. + +The actual values for A and B must be derived based on input that is not available at compile time. + +### State Machine + +This part of the code needs to exercise switch and if statements. As such, we will use a small Moore state machine. In particular, this will be a state machine that identifies string input as numbers and divides them according to format. + +The state machine will parse the input string until either a “,” separator or end of input is encountered. An invalid number will cause the state machine to return invalid state and a valid number will cause the state machine to return with type of number format (int/float/scientific). + +This code will perform a realistic task, be small enough to easily understand, and exercise the required functionality. The other option used in embedded systems is a mealy based state machine, which is driven by a table. The table then determines the number of states and complexity of transitions. This approach, however, tests mainly the load/store and function call mechanisms and less the handling of branches. If analysis of the final results shows that the load/store functionality of the processor is not exercised thoroughly, it may be a good addition to the benchmark (codesize allowing). + +For input, the memory block will be initialized with comma separated values of mixed formats, as well as invalid inputs. + +For the benchmark itself: +- Invoke the state machine on all of the input and count final states and state transitions. CRC of all final states and transitions will become part of the output chain. +- Modify the input at intervals (inject errors) and repeat the state machine operation. +- Modify the input back to original form. + +The actual input must be initialized based on data that cannot be determined at compile time. In addition the intervals for modification of the input and the actual modification must be based on input that cannot be determined at compile time. + +# Validation + +This release was tested on the following platforms: +* x86 cygwin and gcc 3.4 (Quad, dual and single core systems) +* x86 linux (Ubuntu/Fedora) and gcc (4.2/4.1) (Quad and single core systems) +* MIPS64 BE linux and gcc 3.4 16 cores system +* MIPS32 BE linux with CodeSourcery compiler 4.2-177 on Malta/Linux with a 1004K 3-core system +* PPC simulator with gcc 4.2.2 (No OS) +* PPC 64b BE linux (yellowdog) with gcc 3.4 and 4.1 (Dual core system) +* BF533 with VDSP50 +* Renesas R8C/H8 MCU with HEW 4.05 +* NXP LPC1700 armcc v4.0.0.524 +* NEC 78K with IAR v4.61 +* ARM simulator with armcc v4 + +# Memory Analysis + +Valgrind 3.4.0 used and no errors reported. + +# Balance Analysis + +Number of instructions executed for each function tested with cachegrind and found balanced with gcc and -O0. + +# Statistics + +Lines: +~~~ +Lines Blank Cmnts Source AESL +===== ===== ===== ===== ========== ======================================= + 469 66 170 251 627.5 core_list_join.c (C) + 330 18 54 268 670.0 core_main.c (C) + 256 32 80 146 365.0 core_matrix.c (C) + 240 16 51 186 465.0 core_state.c (C) + 165 11 20 134 335.0 core_util.c (C) + 150 23 36 98 245.0 coremark.h (C) + 1610 166 411 1083 2707.5 ----- Benchmark ----- (6 files) + 293 15 74 212 530.0 linux/core_portme.c (C) + 235 30 104 104 260.0 linux/core_portme.h (C) + 528 45 178 316 790.0 ----- Porting ----- (2 files) + +* For comparison, here are the stats for Dhrystone +Lines Blank Cmnts Source AESL +===== ===== ===== ===== ========== ======================================= + 311 15 242 54 135.0 dhry.h (C) + 789 132 119 553 1382.5 dhry_1.c (C) + 186 26 68 107 267.5 dhry_2.c (C) + 1286 173 429 714 1785.0 ----- C ----- (3 files) +~~~ + +# Credits +Many thanks to all of the individuals who helped with the development or testing of CoreMark including (Sorted by company name; note that company names may no longer be accurate as this was written in 2009). +* Alan Anderson, ADI +* Adhikary Rajiv, ADI +* Elena Stohr, ARM +* Ian Rickards, ARM +* Andrew Pickard, ARM +* Trent Parker, CAVIUM +* Shay Gal-On, EEMBC +* Markus Levy, EEMBC +* Ron Olson, IBM +* Eyal Barzilay, MIPS +* Jens Eltze, NEC +* Hirohiko Ono, NEC +* Ulrich Drees, NEC +* Frank Roscheda, NEC +* Rob Cosaro, NXP +* Shumpei Kawasaki, RENESAS + +# Legal +Please refer to LICENSE.md in this reposity for a description of your rights to use this code. + +# Copyright +Copyright © 2009 EEMBC All rights reserved. +CoreMark is a trademark of EEMBC and EEMBC is a registered trademark of the Embedded Microprocessor Benchmark Consortium. + diff --git a/barebones/core_portme.c b/barebones/core_portme.c new file mode 100755 index 0000000..241fd5a --- /dev/null +++ b/barebones/core_portme.c @@ -0,0 +1,118 @@ +/* + File : core_portme.c +*/ +/* + Author : Shay Gal-On, EEMBC + Legal : TODO! +*/ +#include "coremark.h" +#include "core_portme.h" + +#if VALIDATION_RUN + volatile ee_s32 seed1_volatile=0x3415; + volatile ee_s32 seed2_volatile=0x3415; + volatile ee_s32 seed3_volatile=0x66; +#endif +#if PERFORMANCE_RUN + volatile ee_s32 seed1_volatile=0x0; + volatile ee_s32 seed2_volatile=0x0; + volatile ee_s32 seed3_volatile=0x66; +#endif +#if PROFILE_RUN + volatile ee_s32 seed1_volatile=0x8; + volatile ee_s32 seed2_volatile=0x8; + volatile ee_s32 seed3_volatile=0x8; +#endif + volatile ee_s32 seed4_volatile=ITERATIONS; + volatile ee_s32 seed5_volatile=0; +/* Porting : Timing functions + How to capture time and convert to seconds must be ported to whatever is supported by the platform. + e.g. Read value from on board RTC, read value from cpu clock cycles performance counter etc. + Sample implementation for standard time.h and windows.h definitions included. +*/ +CORETIMETYPE barebones_clock() { + #error "You must implement a method to measure time in barebones_clock()! This function should return current time.\n" +} +/* Define : TIMER_RES_DIVIDER + Divider to trade off timer resolution and total time that can be measured. + + Use lower values to increase resolution, but make sure that overflow does not occur. + If there are issues with the return value overflowing, increase this value. + */ +#define GETMYTIME(_t) (*_t=barebones_clock()) +#define MYTIMEDIFF(fin,ini) ((fin)-(ini)) +#define TIMER_RES_DIVIDER 1 +#define SAMPLE_TIME_IMPLEMENTATION 1 +#define EE_TICKS_PER_SEC (CLOCKS_PER_SEC / TIMER_RES_DIVIDER) + +/** Define Host specific (POSIX), or target specific global time variables. */ +static CORETIMETYPE start_time_val, stop_time_val; + +/* Function : start_time + This function will be called right before starting the timed portion of the benchmark. + + Implementation may be capturing a system timer (as implemented in the example code) + or zeroing some system parameters - e.g. setting the cpu clocks cycles to 0. +*/ +void start_time(void) { + GETMYTIME(&start_time_val ); +} +/* Function : stop_time + This function will be called right after ending the timed portion of the benchmark. + + Implementation may be capturing a system timer (as implemented in the example code) + or other system parameters - e.g. reading the current value of cpu cycles counter. +*/ +void stop_time(void) { + GETMYTIME(&stop_time_val ); +} +/* Function : get_time + Return an abstract "ticks" number that signifies time on the system. + + Actual value returned may be cpu cycles, milliseconds or any other value, + as long as it can be converted to seconds by . + This methodology is taken to accomodate any hardware or simulated platform. + The sample implementation returns millisecs by default, + and the resolution is controlled by +*/ +CORE_TICKS get_time(void) { + CORE_TICKS elapsed=(CORE_TICKS)(MYTIMEDIFF(stop_time_val, start_time_val)); + return elapsed; +} +/* Function : time_in_secs + Convert the value returned by get_time to seconds. + + The type is used to accomodate systems with no support for floating point. + Default implementation implemented by the EE_TICKS_PER_SEC macro above. +*/ +secs_ret time_in_secs(CORE_TICKS ticks) { + secs_ret retval=((secs_ret)ticks) / (secs_ret)EE_TICKS_PER_SEC; + return retval; +} + +ee_u32 default_num_contexts=1; + +/* Function : portable_init + Target specific initialization code + Test for some common mistakes. +*/ +void portable_init(core_portable *p, int *argc, char *argv[]) +{ + #error "Call board initialization routines in portable init (if needed), in particular initialize UART!\n" + if (sizeof(ee_ptr_int) != sizeof(ee_u8 *)) { + ee_printf("ERROR! Please define ee_ptr_int to a type that holds a pointer!\n"); + } + if (sizeof(ee_u32) != 4) { + ee_printf("ERROR! Please define ee_u32 to a 32b unsigned type!\n"); + } + p->portable_id=1; +} +/* Function : portable_fini + Target specific final code +*/ +void portable_fini(core_portable *p) +{ + p->portable_id=0; +} + + diff --git a/barebones/core_portme.h b/barebones/core_portme.h new file mode 100755 index 0000000..6de0a10 --- /dev/null +++ b/barebones/core_portme.h @@ -0,0 +1,188 @@ +/* File : core_portme.h */ + +/* + Author : Shay Gal-On, EEMBC + Legal : TODO! +*/ +/* Topic : Description + This file contains configuration constants required to execute on different platforms +*/ +#ifndef CORE_PORTME_H +#define CORE_PORTME_H +/************************/ +/* Data types and settings */ +/************************/ +/* Configuration : HAS_FLOAT + Define to 1 if the platform supports floating point. +*/ +#ifndef HAS_FLOAT +#define HAS_FLOAT 1 +#endif +/* Configuration : HAS_TIME_H + Define to 1 if platform has the time.h header file, + and implementation of functions thereof. +*/ +#ifndef HAS_TIME_H +#define HAS_TIME_H 1 +#endif +/* Configuration : USE_CLOCK + Define to 1 if platform has the time.h header file, + and implementation of functions thereof. +*/ +#ifndef USE_CLOCK +#define USE_CLOCK 1 +#endif +/* Configuration : HAS_STDIO + Define to 1 if the platform has stdio.h. +*/ +#ifndef HAS_STDIO +#define HAS_STDIO 0 +#endif +/* Configuration : HAS_PRINTF + Define to 1 if the platform has stdio.h and implements the printf function. +*/ +#ifndef HAS_PRINTF +#define HAS_PRINTF 0 +#endif + + +/* Definitions : COMPILER_VERSION, COMPILER_FLAGS, MEM_LOCATION + Initialize these strings per platform +*/ +#ifndef COMPILER_VERSION + #ifdef __GNUC__ + #define COMPILER_VERSION "GCC"__VERSION__ + #else + #define COMPILER_VERSION "Please put compiler version here (e.g. gcc 4.1)" + #endif +#endif +#ifndef COMPILER_FLAGS + #define COMPILER_FLAGS FLAGS_STR /* "Please put compiler flags here (e.g. -o3)" */ +#endif +#ifndef MEM_LOCATION + #define MEM_LOCATION "STACK" +#endif + +/* Data Types : + To avoid compiler issues, define the data types that need ot be used for 8b, 16b and 32b in . + + *Imprtant* : + ee_ptr_int needs to be the data type used to hold pointers, otherwise coremark may fail!!! +*/ +typedef signed short ee_s16; +typedef unsigned short ee_u16; +typedef signed int ee_s32; +typedef double ee_f32; +typedef unsigned char ee_u8; +typedef unsigned int ee_u32; +typedef ee_u32 ee_ptr_int; +typedef size_t ee_size_t; +#define NULL ((void *)0) +/* align_mem : + This macro is used to align an offset to point to a 32b value. It is used in the Matrix algorithm to initialize the input memory blocks. +*/ +#define align_mem(x) (void *)(4 + (((ee_ptr_int)(x) - 1) & ~3)) + +/* Configuration : CORE_TICKS + Define type of return from the timing functions. + */ +#define CORETIMETYPE ee_u32 +typedef ee_u32 CORE_TICKS; + +/* Configuration : SEED_METHOD + Defines method to get seed values that cannot be computed at compile time. + + Valid values : + SEED_ARG - from command line. + SEED_FUNC - from a system function. + SEED_VOLATILE - from volatile variables. +*/ +#ifndef SEED_METHOD +#define SEED_METHOD SEED_VOLATILE +#endif + +/* Configuration : MEM_METHOD + Defines method to get a block of memry. + + Valid values : + MEM_MALLOC - for platforms that implement malloc and have malloc.h. + MEM_STATIC - to use a static memory array. + MEM_STACK - to allocate the data block on the stack (NYI). +*/ +#ifndef MEM_METHOD +#define MEM_METHOD MEM_STACK +#endif + +/* Configuration : MULTITHREAD + Define for parallel execution + + Valid values : + 1 - only one context (default). + N>1 - will execute N copies in parallel. + + Note : + If this flag is defined to more then 1, an implementation for launching parallel contexts must be defined. + + Two sample implementations are provided. Use or to enable them. + + It is valid to have a different implementation of and in , + to fit a particular architecture. +*/ +#ifndef MULTITHREAD +#define MULTITHREAD 1 +#define USE_PTHREAD 0 +#define USE_FORK 0 +#define USE_SOCKET 0 +#endif + +/* Configuration : MAIN_HAS_NOARGC + Needed if platform does not support getting arguments to main. + + Valid values : + 0 - argc/argv to main is supported + 1 - argc/argv to main is not supported + + Note : + This flag only matters if MULTITHREAD has been defined to a value greater then 1. +*/ +#ifndef MAIN_HAS_NOARGC +#define MAIN_HAS_NOARGC 0 +#endif + +/* Configuration : MAIN_HAS_NORETURN + Needed if platform does not support returning a value from main. + + Valid values : + 0 - main returns an int, and return value will be 0. + 1 - platform does not support returning a value from main +*/ +#ifndef MAIN_HAS_NORETURN +#define MAIN_HAS_NORETURN 0 +#endif + +/* Variable : default_num_contexts + Not used for this simple port, must cintain the value 1. +*/ +extern ee_u32 default_num_contexts; + +typedef struct CORE_PORTABLE_S { + ee_u8 portable_id; +} core_portable; + +/* target specific init/fini */ +void portable_init(core_portable *p, int *argc, char *argv[]); +void portable_fini(core_portable *p); + +#if !defined(PROFILE_RUN) && !defined(PERFORMANCE_RUN) && !defined(VALIDATION_RUN) +#if (TOTAL_DATA_SIZE==1200) +#define PROFILE_RUN 1 +#elif (TOTAL_DATA_SIZE==2000) +#define PERFORMANCE_RUN 1 +#else +#define VALIDATION_RUN 1 +#endif +#endif + +int ee_printf(const char *fmt, ...); + +#endif /* CORE_PORTME_H */ diff --git a/barebones/core_portme.mak b/barebones/core_portme.mak new file mode 100755 index 0000000..c423749 --- /dev/null +++ b/barebones/core_portme.mak @@ -0,0 +1,71 @@ +#File : core_portme.mak + +# Flag : OUTFLAG +# Use this flag to define how to to get an executable (e.g -o) +OUTFLAG= -o +# Flag : CC +# Use this flag to define compiler to use +CC = gcc +# Flag : LD +# Use this flag to define compiler to use +LD = gld +# Flag : AS +# Use this flag to define compiler to use +AS = gas +# Flag : CFLAGS +# Use this flag to define compiler options. Note, you can add compiler options from the command line using XCFLAGS="other flags" +PORT_CFLAGS = -O0 -g +FLAGS_STR = "$(PORT_CFLAGS) $(XCFLAGS) $(XLFLAGS) $(LFLAGS_END)" +CFLAGS = $(PORT_CFLAGS) -I$(PORT_DIR) -I. -DFLAGS_STR=\"$(FLAGS_STR)\" +#Flag : LFLAGS_END +# Define any libraries needed for linking or other flags that should come at the end of the link line (e.g. linker scripts). +# Note : On certain platforms, the default clock_gettime implementation is supported but requires linking of librt. +SEPARATE_COMPILE=1 +# Flag : SEPARATE_COMPILE +# You must also define below how to create an object file, and how to link. +OBJOUT = -o +LFLAGS = +ASFLAGS = +OFLAG = -o +COUT = -c + +LFLAGS_END = +# Flag : PORT_SRCS +# Port specific source files can be added here +# You may also need cvt.c if the fcvt functions are not provided as intrinsics by your compiler! +PORT_SRCS = $(PORT_DIR)/core_portme.c $(PORT_DIR)/ee_printf.c +vpath %.c $(PORT_DIR) +vpath %.s $(PORT_DIR) + +# Flag : LOAD +# For a simple port, we assume self hosted compile and run, no load needed. + +# Flag : RUN +# For a simple port, we assume self hosted compile and run, simple invocation of the executable + +LOAD = echo "Please set LOAD to the process of loading the executable to the flash" +RUN = echo "Please set LOAD to the process of running the executable (e.g. via jtag, or board reset)" + +OEXT = .o +EXE = .bin + +$(OPATH)$(PORT_DIR)/%$(OEXT) : %.c + $(CC) $(CFLAGS) $(XCFLAGS) $(COUT) $< $(OBJOUT) $@ + +$(OPATH)%$(OEXT) : %.c + $(CC) $(CFLAGS) $(XCFLAGS) $(COUT) $< $(OBJOUT) $@ + +$(OPATH)$(PORT_DIR)/%$(OEXT) : %.s + $(AS) $(ASFLAGS) $< $(OBJOUT) $@ + +# Target : port_pre% and port_post% +# For the purpose of this simple port, no pre or post steps needed. + +.PHONY : port_prebuild port_postbuild port_prerun port_postrun port_preload port_postload +port_pre% port_post% : + +# FLAG : OPATH +# Path to the output folder. Default - current folder. +OPATH = ./ +MKDIR = mkdir -p + diff --git a/barebones/cvt.c b/barebones/cvt.c new file mode 100755 index 0000000..e7594e9 --- /dev/null +++ b/barebones/cvt.c @@ -0,0 +1,102 @@ +#include +#define CVTBUFSIZE 80 +static char CVTBUF[CVTBUFSIZE]; + +static char *cvt(double arg, int ndigits, int *decpt, int *sign, char *buf, int eflag) +{ + int r2; + double fi, fj; + char *p, *p1; + + if (ndigits < 0) ndigits = 0; + if (ndigits >= CVTBUFSIZE - 1) ndigits = CVTBUFSIZE - 2; + r2 = 0; + *sign = 0; + p = &buf[0]; + if (arg < 0) + { + *sign = 1; + arg = -arg; + } + arg = modf(arg, &fi); + p1 = &buf[CVTBUFSIZE]; + + if (fi != 0) + { + p1 = &buf[CVTBUFSIZE]; + while (fi != 0) + { + fj = modf(fi / 10, &fi); + *--p1 = (int)((fj + .03) * 10) + '0'; + r2++; + } + while (p1 < &buf[CVTBUFSIZE]) *p++ = *p1++; + } + else if (arg > 0) + { + while ((fj = arg * 10) < 1) + { + arg = fj; + r2--; + } + } + p1 = &buf[ndigits]; + if (eflag == 0) p1 += r2; + *decpt = r2; + if (p1 < &buf[0]) + { + buf[0] = '\0'; + return buf; + } + while (p <= p1 && p < &buf[CVTBUFSIZE]) + { + arg *= 10; + arg = modf(arg, &fj); + *p++ = (int) fj + '0'; + } + if (p1 >= &buf[CVTBUFSIZE]) + { + buf[CVTBUFSIZE - 1] = '\0'; + return buf; + } + p = p1; + *p1 += 5; + while (*p1 > '9') + { + *p1 = '0'; + if (p1 > buf) + ++*--p1; + else + { + *p1 = '1'; + (*decpt)++; + if (eflag == 0) + { + if (p > buf) *p = '0'; + p++; + } + } + } + *p = '\0'; + return buf; +} + +char *ecvt(double arg, int ndigits, int *decpt, int *sign) +{ + return cvt(arg, ndigits, decpt, sign, CVTBUF, 1); +} + +char *ecvtbuf(double arg, int ndigits, int *decpt, int *sign, char *buf) +{ + return cvt(arg, ndigits, decpt, sign, buf, 1); +} + +char *fcvt(double arg, int ndigits, int *decpt, int *sign) +{ + return cvt(arg, ndigits, decpt, sign, CVTBUF, 0); +} + +char *fcvtbuf(double arg, int ndigits, int *decpt, int *sign, char *buf) +{ + return cvt(arg, ndigits, decpt, sign, buf, 0); +} diff --git a/barebones/ee_printf.c b/barebones/ee_printf.c new file mode 100755 index 0000000..b1e86a5 --- /dev/null +++ b/barebones/ee_printf.c @@ -0,0 +1,614 @@ +/* File : barebones/ee_printf.c + This file contains an implementation of ee_printf that only requires a method to output a char to a UART without pulling in library code. + +This code is based on a file that contains the following: + Copyright (C) 2002 Michael Ringgaard. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + 3. Neither the name of the project nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + SUCH DAMAGE. + +*/ + +#include +#include + +#define ZEROPAD (1<<0) /* Pad with zero */ +#define SIGN (1<<1) /* Unsigned/signed long */ +#define PLUS (1<<2) /* Show plus */ +#define SPACE (1<<3) /* Spacer */ +#define LEFT (1<<4) /* Left justified */ +#define HEX_PREP (1<<5) /* 0x */ +#define UPPERCASE (1<<6) /* 'ABCDEF' */ + +#define is_digit(c) ((c) >= '0' && (c) <= '9') + +static char *digits = "0123456789abcdefghijklmnopqrstuvwxyz"; +static char *upper_digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; +static size_t strnlen(const char *s, size_t count); + +static size_t strnlen(const char *s, size_t count) +{ + const char *sc; + for (sc = s; *sc != '\0' && count--; ++sc); + return sc - s; +} + +static int skip_atoi(const char **s) +{ + int i = 0; + while (is_digit(**s)) i = i*10 + *((*s)++) - '0'; + return i; +} + +static char *number(char *str, long num, int base, int size, int precision, int type) +{ + char c, sign, tmp[66]; + char *dig = digits; + int i; + + if (type & UPPERCASE) dig = upper_digits; + if (type & LEFT) type &= ~ZEROPAD; + if (base < 2 || base > 36) return 0; + + c = (type & ZEROPAD) ? '0' : ' '; + sign = 0; + if (type & SIGN) + { + if (num < 0) + { + sign = '-'; + num = -num; + size--; + } + else if (type & PLUS) + { + sign = '+'; + size--; + } + else if (type & SPACE) + { + sign = ' '; + size--; + } + } + + if (type & HEX_PREP) + { + if (base == 16) + size -= 2; + else if (base == 8) + size--; + } + + i = 0; + + if (num == 0) + tmp[i++] = '0'; + else + { + while (num != 0) + { + tmp[i++] = dig[((unsigned long) num) % (unsigned) base]; + num = ((unsigned long) num) / (unsigned) base; + } + } + + if (i > precision) precision = i; + size -= precision; + if (!(type & (ZEROPAD | LEFT))) while (size-- > 0) *str++ = ' '; + if (sign) *str++ = sign; + + if (type & HEX_PREP) + { + if (base == 8) + *str++ = '0'; + else if (base == 16) + { + *str++ = '0'; + *str++ = digits[33]; + } + } + + if (!(type & LEFT)) while (size-- > 0) *str++ = c; + while (i < precision--) *str++ = '0'; + while (i-- > 0) *str++ = tmp[i]; + while (size-- > 0) *str++ = ' '; + + return str; +} + +static char *eaddr(char *str, unsigned char *addr, int size, int precision, int type) +{ + char tmp[24]; + char *dig = digits; + int i, len; + + if (type & UPPERCASE) dig = upper_digits; + len = 0; + for (i = 0; i < 6; i++) + { + if (i != 0) tmp[len++] = ':'; + tmp[len++] = dig[addr[i] >> 4]; + tmp[len++] = dig[addr[i] & 0x0F]; + } + + if (!(type & LEFT)) while (len < size--) *str++ = ' '; + for (i = 0; i < len; ++i) *str++ = tmp[i]; + while (len < size--) *str++ = ' '; + + return str; +} + +static char *iaddr(char *str, unsigned char *addr, int size, int precision, int type) +{ + char tmp[24]; + int i, n, len; + + len = 0; + for (i = 0; i < 4; i++) + { + if (i != 0) tmp[len++] = '.'; + n = addr[i]; + + if (n == 0) + tmp[len++] = digits[0]; + else + { + if (n >= 100) + { + tmp[len++] = digits[n / 100]; + n = n % 100; + tmp[len++] = digits[n / 10]; + n = n % 10; + } + else if (n >= 10) + { + tmp[len++] = digits[n / 10]; + n = n % 10; + } + + tmp[len++] = digits[n]; + } + } + + if (!(type & LEFT)) while (len < size--) *str++ = ' '; + for (i = 0; i < len; ++i) *str++ = tmp[i]; + while (len < size--) *str++ = ' '; + + return str; +} + +#ifdef HAS_FLOAT + +char *ecvtbuf(double arg, int ndigits, int *decpt, int *sign, char *buf); +char *fcvtbuf(double arg, int ndigits, int *decpt, int *sign, char *buf); +static void ee_bufcpy(char *d, char *s, int count); + +void ee_bufcpy(char *pd, char *ps, int count) { + char *pe=ps+count; + while (ps!=pe) + *pd++=*ps++; +} + +static void parse_float(double value, char *buffer, char fmt, int precision) +{ + int decpt, sign, exp, pos; + char *digits = NULL; + char cvtbuf[80]; + int capexp = 0; + int magnitude; + + if (fmt == 'G' || fmt == 'E') + { + capexp = 1; + fmt += 'a' - 'A'; + } + + if (fmt == 'g') + { + digits = ecvtbuf(value, precision, &decpt, &sign, cvtbuf); + magnitude = decpt - 1; + if (magnitude < -4 || magnitude > precision - 1) + { + fmt = 'e'; + precision -= 1; + } + else + { + fmt = 'f'; + precision -= decpt; + } + } + + if (fmt == 'e') + { + digits = ecvtbuf(value, precision + 1, &decpt, &sign, cvtbuf); + + if (sign) *buffer++ = '-'; + *buffer++ = *digits; + if (precision > 0) *buffer++ = '.'; + ee_bufcpy(buffer, digits + 1, precision); + buffer += precision; + *buffer++ = capexp ? 'E' : 'e'; + + if (decpt == 0) + { + if (value == 0.0) + exp = 0; + else + exp = -1; + } + else + exp = decpt - 1; + + if (exp < 0) + { + *buffer++ = '-'; + exp = -exp; + } + else + *buffer++ = '+'; + + buffer[2] = (exp % 10) + '0'; + exp = exp / 10; + buffer[1] = (exp % 10) + '0'; + exp = exp / 10; + buffer[0] = (exp % 10) + '0'; + buffer += 3; + } + else if (fmt == 'f') + { + digits = fcvtbuf(value, precision, &decpt, &sign, cvtbuf); + if (sign) *buffer++ = '-'; + if (*digits) + { + if (decpt <= 0) + { + *buffer++ = '0'; + *buffer++ = '.'; + for (pos = 0; pos < -decpt; pos++) *buffer++ = '0'; + while (*digits) *buffer++ = *digits++; + } + else + { + pos = 0; + while (*digits) + { + if (pos++ == decpt) *buffer++ = '.'; + *buffer++ = *digits++; + } + } + } + else + { + *buffer++ = '0'; + if (precision > 0) + { + *buffer++ = '.'; + for (pos = 0; pos < precision; pos++) *buffer++ = '0'; + } + } + } + + *buffer = '\0'; +} + +static void decimal_point(char *buffer) +{ + while (*buffer) + { + if (*buffer == '.') return; + if (*buffer == 'e' || *buffer == 'E') break; + buffer++; + } + + if (*buffer) + { + int n = strnlen(buffer,256); + while (n > 0) + { + buffer[n + 1] = buffer[n]; + n--; + } + + *buffer = '.'; + } + else + { + *buffer++ = '.'; + *buffer = '\0'; + } +} + +static void cropzeros(char *buffer) +{ + char *stop; + + while (*buffer && *buffer != '.') buffer++; + if (*buffer++) + { + while (*buffer && *buffer != 'e' && *buffer != 'E') buffer++; + stop = buffer--; + while (*buffer == '0') buffer--; + if (*buffer == '.') buffer--; + while (buffer!=stop) + *++buffer=0; + } +} + +static char *flt(char *str, double num, int size, int precision, char fmt, int flags) +{ + char tmp[80]; + char c, sign; + int n, i; + + // Left align means no zero padding + if (flags & LEFT) flags &= ~ZEROPAD; + + // Determine padding and sign char + c = (flags & ZEROPAD) ? '0' : ' '; + sign = 0; + if (flags & SIGN) + { + if (num < 0.0) + { + sign = '-'; + num = -num; + size--; + } + else if (flags & PLUS) + { + sign = '+'; + size--; + } + else if (flags & SPACE) + { + sign = ' '; + size--; + } + } + + // Compute the precision value + if (precision < 0) + precision = 6; // Default precision: 6 + + // Convert floating point number to text + parse_float(num, tmp, fmt, precision); + + if ((flags & HEX_PREP) && precision == 0) decimal_point(tmp); + if (fmt == 'g' && !(flags & HEX_PREP)) cropzeros(tmp); + + n = strnlen(tmp,256); + + // Output number with alignment and padding + size -= n; + if (!(flags & (ZEROPAD | LEFT))) while (size-- > 0) *str++ = ' '; + if (sign) *str++ = sign; + if (!(flags & LEFT)) while (size-- > 0) *str++ = c; + for (i = 0; i < n; i++) *str++ = tmp[i]; + while (size-- > 0) *str++ = ' '; + + return str; +} + +#endif + +static int ee_vsprintf(char *buf, const char *fmt, va_list args) +{ + int len; + unsigned long num; + int i, base; + char *str; + char *s; + + int flags; // Flags to number() + + int field_width; // Width of output field + int precision; // Min. # of digits for integers; max number of chars for from string + int qualifier; // 'h', 'l', or 'L' for integer fields + + for (str = buf; *fmt; fmt++) + { + if (*fmt != '%') + { + *str++ = *fmt; + continue; + } + + // Process flags + flags = 0; +repeat: + fmt++; // This also skips first '%' + switch (*fmt) + { + case '-': flags |= LEFT; goto repeat; + case '+': flags |= PLUS; goto repeat; + case ' ': flags |= SPACE; goto repeat; + case '#': flags |= HEX_PREP; goto repeat; + case '0': flags |= ZEROPAD; goto repeat; + } + + // Get field width + field_width = -1; + if (is_digit(*fmt)) + field_width = skip_atoi(&fmt); + else if (*fmt == '*') + { + fmt++; + field_width = va_arg(args, int); + if (field_width < 0) + { + field_width = -field_width; + flags |= LEFT; + } + } + + // Get the precision + precision = -1; + if (*fmt == '.') + { + ++fmt; + if (is_digit(*fmt)) + precision = skip_atoi(&fmt); + else if (*fmt == '*') + { + ++fmt; + precision = va_arg(args, int); + } + if (precision < 0) precision = 0; + } + + // Get the conversion qualifier + qualifier = -1; + if (*fmt == 'l' || *fmt == 'L') + { + qualifier = *fmt; + fmt++; + } + + // Default base + base = 10; + + switch (*fmt) + { + case 'c': + if (!(flags & LEFT)) while (--field_width > 0) *str++ = ' '; + *str++ = (unsigned char) va_arg(args, int); + while (--field_width > 0) *str++ = ' '; + continue; + + case 's': + s = va_arg(args, char *); + if (!s) s = ""; + len = strnlen(s, precision); + if (!(flags & LEFT)) while (len < field_width--) *str++ = ' '; + for (i = 0; i < len; ++i) *str++ = *s++; + while (len < field_width--) *str++ = ' '; + continue; + + case 'p': + if (field_width == -1) + { + field_width = 2 * sizeof(void *); + flags |= ZEROPAD; + } + str = number(str, (unsigned long) va_arg(args, void *), 16, field_width, precision, flags); + continue; + + case 'A': + flags |= UPPERCASE; + + case 'a': + if (qualifier == 'l') + str = eaddr(str, va_arg(args, unsigned char *), field_width, precision, flags); + else + str = iaddr(str, va_arg(args, unsigned char *), field_width, precision, flags); + continue; + + // Integer number formats - set up the flags and "break" + case 'o': + base = 8; + break; + + case 'X': + flags |= UPPERCASE; + + case 'x': + base = 16; + break; + + case 'd': + case 'i': + flags |= SIGN; + + case 'u': + break; + +#ifdef HAS_FLOAT + + case 'f': + str = flt(str, va_arg(args, double), field_width, precision, *fmt, flags | SIGN); + continue; + +#endif + + default: + if (*fmt != '%') *str++ = '%'; + if (*fmt) + *str++ = *fmt; + else + --fmt; + continue; + } + + if (qualifier == 'l') + num = va_arg(args, unsigned long); + else if (flags & SIGN) + num = va_arg(args, int); + else + num = va_arg(args, unsigned int); + + str = number(str, num, base, field_width, precision, flags); + } + + *str = '\0'; + return str - buf; +} + +void uart_send_char(char c) { +#error "You must implement the method uart_send_char to use this file!\n"; +/* Output of a char to a UART usually follows the following model: + Wait until UART is ready + Write char to UART + Wait until UART is done + + Or in code: + while (*UART_CONTROL_ADDRESS != UART_READY); + *UART_DATA_ADDRESS = c; + while (*UART_CONTROL_ADDRESS != UART_READY); + + Check the UART sample code on your platform or the board documentation. +*/ +} + +int ee_printf(const char *fmt, ...) +{ + char buf[256],*p; + va_list args; + int n=0; + + va_start(args, fmt); + ee_vsprintf(buf, fmt, args); + va_end(args); + p=buf; + while (*p) { + uart_send_char(*p); + n++; + p++; + } + + return n; +} + diff --git a/core_list_join.c b/core_list_join.c new file mode 100644 index 0000000..dd2d4d7 --- /dev/null +++ b/core_list_join.c @@ -0,0 +1,496 @@ +/* +Author : Shay Gal-On, EEMBC + +This file is part of EEMBC(R) and CoreMark(TM), which are Copyright (C) 2009 +All rights reserved. + +EEMBC CoreMark Software is a product of EEMBC and is provided under the terms of the +CoreMark License that is distributed with the official EEMBC COREMARK Software release. +If you received this EEMBC CoreMark Software without the accompanying CoreMark License, +you must discontinue use and download the official release from www.coremark.org. + +Also, if you are publicly displaying scores generated from the EEMBC CoreMark software, +make sure that you are in compliance with Run and Reporting rules specified in the accompanying readme.txt file. + +EEMBC +4354 Town Center Blvd. Suite 114-200 +El Dorado Hills, CA, 95762 +*/ + +#include "coremark.h" +/* +Topic: Description + Benchmark using a linked list. + + Linked list is a common data structure used in many applications. + + For our purposes, this will excercise the memory units of the processor. + In particular, usage of the list pointers to find and alter data. + + We are not using Malloc since some platforms do not support this library. + + Instead, the memory block being passed in is used to create a list, + and the benchmark takes care not to add more items then can be + accomodated by the memory block. The porting layer will make sure + that we have a valid memory block. + + All operations are done in place, without using any extra memory. + + The list itself contains list pointers and pointers to data items. + Data items contain the following: + + idx - An index that captures the initial order of the list. + data - Variable data initialized based on the input parameters. The 16b are divided as follows: + o Upper 8b are backup of original data. + o Bit 7 indicates if the lower 7 bits are to be used as is or calculated. + o Bits 0-2 indicate type of operation to perform to get a 7b value. + o Bits 3-6 provide input for the operation. + +*/ + +/* local functions */ + +list_head *core_list_find(list_head *list,list_data *info); +list_head *core_list_reverse(list_head *list); +list_head *core_list_remove(list_head *item); +list_head *core_list_undo_remove(list_head *item_removed, list_head *item_modified); +list_head *core_list_insert_new(list_head *insert_point + , list_data *info, list_head **memblock, list_data **datablock + , list_head *memblock_end, list_data *datablock_end); +typedef ee_s32(*list_cmp)(list_data *a, list_data *b, core_results *res); +list_head *core_list_mergesort(list_head *list, list_cmp cmp, core_results *res); + +ee_s16 calc_func(ee_s16 *pdata, core_results *res) { + ee_s16 data=*pdata; + ee_s16 retval; + ee_u8 optype=(data>>7) & 1; /* bit 7 indicates if the function result has been cached */ + if (optype) /* if cached, use cache */ + return (data & 0x007f); + else { /* otherwise calculate and cache the result */ + ee_s16 flag=data & 0x7; /* bits 0-2 is type of function to perform */ + ee_s16 dtype=((data>>3) & 0xf); /* bits 3-6 is specific data for the operation */ + dtype |= dtype << 4; /* replicate the lower 4 bits to get an 8b value */ + switch (flag) { + case 0: + if (dtype<0x22) /* set min period for bit corruption */ + dtype=0x22; + retval=core_bench_state(res->size,res->memblock[3],res->seed1,res->seed2,dtype,res->crc); + if (res->crcstate==0) + res->crcstate=retval; + break; + case 1: + retval=core_bench_matrix(&(res->mat),dtype,res->crc); + if (res->crcmatrix==0) + res->crcmatrix=retval; + break; + default: + retval=data; + break; + } + res->crc=crcu16(retval,res->crc); + retval &= 0x007f; + *pdata = (data & 0xff00) | 0x0080 | retval; /* cache the result */ + return retval; + } +} +/* Function: cmp_complex + Compare the data item in a list cell. + + Can be used by mergesort. +*/ +ee_s32 cmp_complex(list_data *a, list_data *b, core_results *res) { + ee_s16 val1=calc_func(&(a->data16),res); + ee_s16 val2=calc_func(&(b->data16),res); + return val1 - val2; +} + +/* Function: cmp_idx + Compare the idx item in a list cell, and regen the data. + + Can be used by mergesort. +*/ +ee_s32 cmp_idx(list_data *a, list_data *b, core_results *res) { + if (res==NULL) { + a->data16 = (a->data16 & 0xff00) | (0x00ff & (a->data16>>8)); + b->data16 = (b->data16 & 0xff00) | (0x00ff & (b->data16>>8)); + } + return a->idx - b->idx; +} + +void copy_info(list_data *to,list_data *from) { + to->data16=from->data16; + to->idx=from->idx; +} + +/* Benchmark for linked list: + - Try to find multiple data items. + - List sort + - Operate on data from list (crc) + - Single remove/reinsert + * At the end of this function, the list is back to original state +*/ +ee_u16 core_bench_list(core_results *res, ee_s16 finder_idx) { + ee_u16 retval=0; + ee_u16 found=0,missed=0; + list_head *list=res->list; + ee_s16 find_num=res->seed3; + list_head *this_find; + list_head *finder, *remover; + list_data info; + ee_s16 i; + + info.idx=finder_idx; + /* find values in the list, and change the list each time (reverse and cache if value found) */ + for (i=0; inext->info->data16 >> 8) & 1; + } + else { + found++; + if (this_find->info->data16 & 0x1) /* use found value */ + retval+=(this_find->info->data16 >> 9) & 1; + /* and cache next item at the head of the list (if any) */ + if (this_find->next != NULL) { + finder = this_find->next; + this_find->next = finder->next; + finder->next=list->next; + list->next=finder; + } + } + if (info.idx>=0) + info.idx++; +#if CORE_DEBUG + ee_printf("List find %d: [%d,%d,%d]\n",i,retval,missed,found); +#endif + } + retval+=found*4-missed; + /* sort the list by data content and remove one item*/ + if (finder_idx>0) + list=core_list_mergesort(list,cmp_complex,res); + remover=core_list_remove(list->next); + /* CRC data content of list from location of index N forward, and then undo remove */ + finder=core_list_find(list,&info); + if (!finder) + finder=list->next; + while (finder) { + retval=crc16(list->info->data16,retval); + finder=finder->next; + } +#if CORE_DEBUG + ee_printf("List sort 1: %04x\n",retval); +#endif + remover=core_list_undo_remove(remover,list->next); + /* sort the list by index, in effect returning the list to original state */ + list=core_list_mergesort(list,cmp_idx,NULL); + /* CRC data content of list */ + finder=list->next; + while (finder) { + retval=crc16(list->info->data16,retval); + finder=finder->next; + } +#if CORE_DEBUG + ee_printf("List sort 2: %04x\n",retval); +#endif + return retval; +} +/* Function: core_list_init + Initialize list with data. + + Parameters: + blksize - Size of memory to be initialized. + memblock - Pointer to memory block. + seed - Actual values chosen depend on the seed parameter. + The seed parameter MUST be supplied from a source that cannot be determined at compile time + + Returns: + Pointer to the head of the list. + +*/ +list_head *core_list_init(ee_u32 blksize, list_head *memblock, ee_s16 seed) { + /* calculated pointers for the list */ + ee_u32 per_item=16+sizeof(struct list_data_s); + ee_u32 size=(blksize/per_item)-2; /* to accomodate systems with 64b pointers, and make sure same code is executed, set max list elements */ + list_head *memblock_end=memblock+size; + list_data *datablock=(list_data *)(memblock_end); + list_data *datablock_end=datablock+size; + /* some useful variables */ + ee_u32 i; + list_head *finder,*list=memblock; + list_data info; + + /* create a fake items for the list head and tail */ + list->next=NULL; + list->info=datablock; + list->info->idx=0x0000; + list->info->data16=(ee_s16)0x8080; + memblock++; + datablock++; + info.idx=0x7fff; + info.data16=(ee_s16)0xffff; + core_list_insert_new(list,&info,&memblock,&datablock,memblock_end,datablock_end); + + /* then insert size items */ + for (i=0; inext; + i=1; + while (finder->next!=NULL) { + if (iinfo->idx=i++; + else { + ee_u16 pat=(ee_u16)(i++ ^ seed); /* get a pseudo random number */ + finder->info->idx=0x3fff & (((i & 0x07) << 8) | pat); /* make sure the mixed items end up after the ones in sequence */ + } + finder=finder->next; + } + list = core_list_mergesort(list,cmp_idx,NULL); +#if CORE_DEBUG + ee_printf("Initialized list:\n"); + finder=list; + while (finder) { + ee_printf("[%04x,%04x]",finder->info->idx,(ee_u16)finder->info->data16); + finder=finder->next; + } + ee_printf("\n"); +#endif + return list; +} + +/* Function: core_list_insert + Insert an item to the list + + Parameters: + insert_point - where to insert the item. + info - data for the cell. + memblock - pointer for the list header + datablock - pointer for the list data + memblock_end - end of region for list headers + datablock_end - end of region for list data + + Returns: + Pointer to new item. +*/ +list_head *core_list_insert_new(list_head *insert_point, list_data *info, list_head **memblock, list_data **datablock + , list_head *memblock_end, list_data *datablock_end) { + list_head *newitem; + + if ((*memblock+1) >= memblock_end) + return NULL; + if ((*datablock+1) >= datablock_end) + return NULL; + + newitem=*memblock; + (*memblock)++; + newitem->next=insert_point->next; + insert_point->next=newitem; + + newitem->info=*datablock; + (*datablock)++; + copy_info(newitem->info,info); + + return newitem; +} + +/* Function: core_list_remove + Remove an item from the list. + + Operation: + For a singly linked list, remove by copying the data from the next item + over to the current cell, and unlinking the next item. + + Note: + since there is always a fake item at the end of the list, no need to check for NULL. + + Returns: + Removed item. +*/ +list_head *core_list_remove(list_head *item) { + list_data *tmp; + list_head *ret=item->next; + /* swap data pointers */ + tmp=item->info; + item->info=ret->info; + ret->info=tmp; + /* and eliminate item */ + item->next=item->next->next; + ret->next=NULL; + return ret; +} + +/* Function: core_list_undo_remove + Undo a remove operation. + + Operation: + Since we want each iteration of the benchmark to be exactly the same, + we need to be able to undo a remove. + Link the removed item back into the list, and switch the info items. + + Parameters: + item_removed - Return value from the + item_modified - List item that was modified during + + Returns: + The item that was linked back to the list. + +*/ +list_head *core_list_undo_remove(list_head *item_removed, list_head *item_modified) { + list_data *tmp; + /* swap data pointers */ + tmp=item_removed->info; + item_removed->info=item_modified->info; + item_modified->info=tmp; + /* and insert item */ + item_removed->next=item_modified->next; + item_modified->next=item_removed; + return item_removed; +} + +/* Function: core_list_find + Find an item in the list + + Operation: + Find an item by idx (if not 0) or specific data value + + Parameters: + list - list head + info - idx or data to find + + Returns: + Found item, or NULL if not found. +*/ +list_head *core_list_find(list_head *list,list_data *info) { + if (info->idx>=0) { + while (list && (list->info->idx != info->idx)) + list=list->next; + return list; + } else { + while (list && ((list->info->data16 & 0xff) != info->data16)) + list=list->next; + return list; + } +} +/* Function: core_list_reverse + Reverse a list + + Operation: + Rearrange the pointers so the list is reversed. + + Parameters: + list - list head + info - idx or data to find + + Returns: + Found item, or NULL if not found. +*/ + +list_head *core_list_reverse(list_head *list) { + list_head *next=NULL, *tmp; + while (list) { + tmp=list->next; + list->next=next; + next=list; + list=tmp; + } + return next; +} +/* Function: core_list_mergesort + Sort the list in place without recursion. + + Description: + Use mergesort, as for linked list this is a realistic solution. + Also, since this is aimed at embedded, care was taken to use iterative rather then recursive algorithm. + The sort can either return the list to original order (by idx) , + or use the data item to invoke other other algorithms and change the order of the list. + + Parameters: + list - list to be sorted. + cmp - cmp function to use + + Returns: + New head of the list. + + Note: + We have a special header for the list that will always be first, + but the algorithm could theoretically modify where the list starts. + + */ +list_head *core_list_mergesort(list_head *list, list_cmp cmp, core_results *res) { + list_head *p, *q, *e, *tail; + ee_s32 insize, nmerges, psize, qsize, i; + + insize = 1; + + while (1) { + p = list; + list = NULL; + tail = NULL; + + nmerges = 0; /* count number of merges we do in this pass */ + + while (p) { + nmerges++; /* there exists a merge to be done */ + /* step `insize' places along from p */ + q = p; + psize = 0; + for (i = 0; i < insize; i++) { + psize++; + q = q->next; + if (!q) break; + } + + /* if q hasn't fallen off end, we have two lists to merge */ + qsize = insize; + + /* now we have two lists; merge them */ + while (psize > 0 || (qsize > 0 && q)) { + + /* decide whether next element of merge comes from p or q */ + if (psize == 0) { + /* p is empty; e must come from q. */ + e = q; q = q->next; qsize--; + } else if (qsize == 0 || !q) { + /* q is empty; e must come from p. */ + e = p; p = p->next; psize--; + } else if (cmp(p->info,q->info,res) <= 0) { + /* First element of p is lower (or same); e must come from p. */ + e = p; p = p->next; psize--; + } else { + /* First element of q is lower; e must come from q. */ + e = q; q = q->next; qsize--; + } + + /* add the next element to the merged list */ + if (tail) { + tail->next = e; + } else { + list = e; + } + tail = e; + } + + /* now p has stepped `insize' places along, and q has too */ + p = q; + } + + tail->next = NULL; + + /* If we have done only one merge, we're finished. */ + if (nmerges <= 1) /* allow for nmerges==0, the empty list case */ + return list; + + /* Otherwise repeat, merging lists twice the size */ + insize *= 2; + } +#if COMPILER_REQUIRES_SORT_RETURN + return list; +#endif +} diff --git a/core_main.c b/core_main.c new file mode 100644 index 0000000..c4145ec --- /dev/null +++ b/core_main.c @@ -0,0 +1,356 @@ +/* +Author : Shay Gal-On, EEMBC + +This file is part of EEMBC(R) and CoreMark(TM), which are Copyright (C) 2009 +All rights reserved. + +EEMBC CoreMark Software is a product of EEMBC and is provided under the terms of the +CoreMark License that is distributed with the official EEMBC COREMARK Software release. +If you received this EEMBC CoreMark Software without the accompanying CoreMark License, +you must discontinue use and download the official release from www.coremark.org. + +Also, if you are publicly displaying scores generated from the EEMBC CoreMark software, +make sure that you are in compliance with Run and Reporting rules specified in the accompanying readme.txt file. + +EEMBC +4354 Town Center Blvd. Suite 114-200 +El Dorado Hills, CA, 95762 +*/ +/* File: core_main.c + This file contains the framework to acquire a block of memory, seed initial parameters, tun t he benchmark and report the results. +*/ +#include "coremark.h" + +/* Function: iterate + Run the benchmark for a specified number of iterations. + + Operation: + For each type of benchmarked algorithm: + a - Initialize the data block for the algorithm. + b - Execute the algorithm N times. + + Returns: + NULL. +*/ +static ee_u16 list_known_crc[] = {(ee_u16)0xd4b0,(ee_u16)0x3340,(ee_u16)0x6a79,(ee_u16)0xe714,(ee_u16)0xe3c1}; +static ee_u16 matrix_known_crc[] = {(ee_u16)0xbe52,(ee_u16)0x1199,(ee_u16)0x5608,(ee_u16)0x1fd7,(ee_u16)0x0747}; +static ee_u16 state_known_crc[] = {(ee_u16)0x5e47,(ee_u16)0x39bf,(ee_u16)0xe5a4,(ee_u16)0x8e3a,(ee_u16)0x8d84}; +void *iterate(void *pres) { + ee_u32 i; + ee_u16 crc; + core_results *res=(core_results *)pres; + ee_u32 iterations=res->iterations; + res->crc=0; + res->crclist=0; + res->crcmatrix=0; + res->crcstate=0; + + for (i=0; icrc=crcu16(crc,res->crc); + crc=core_bench_list(res,-1); + res->crc=crcu16(crc,res->crc); + if (i==0) res->crclist=res->crc; + } + return NULL; +} + +#if (SEED_METHOD==SEED_ARG) +ee_s32 get_seed_args(int i, int argc, char *argv[]); +#define get_seed(x) (ee_s16)get_seed_args(x,argc,argv) +#define get_seed_32(x) get_seed_args(x,argc,argv) +#else /* via function or volatile */ +ee_s32 get_seed_32(int i); +#define get_seed(x) (ee_s16)get_seed_32(x) +#endif + +#if (MEM_METHOD==MEM_STATIC) +ee_u8 static_memblk[TOTAL_DATA_SIZE]; +#endif +char *mem_name[3] = {"Static","Heap","Stack"}; +/* Function: main + Main entry routine for the benchmark. + This function is responsible for the following steps: + + 1 - Initialize input seeds from a source that cannot be determined at compile time. + 2 - Initialize memory block for use. + 3 - Run and time the benchmark. + 4 - Report results, testing the validity of the output if the seeds are known. + + Arguments: + 1 - first seed : Any value + 2 - second seed : Must be identical to first for iterations to be identical + 3 - third seed : Any value, should be at least an order of magnitude less then the input size, but bigger then 32. + 4 - Iterations : Special, if set to 0, iterations will be automatically determined such that the benchmark will run between 10 to 100 secs + +*/ + +#if MAIN_HAS_NOARGC +MAIN_RETURN_TYPE main(void) { + int argc=0; + char *argv[1]; +#else +MAIN_RETURN_TYPE main(int argc, char *argv[]) { +#endif + ee_u16 i,j=0,num_algorithms=0; + ee_s16 known_id=-1,total_errors=0; + ee_u16 seedcrc=0; + CORE_TICKS total_time; + core_results results[MULTITHREAD]; +#if (MEM_METHOD==MEM_STACK) + ee_u8 stack_memblock[TOTAL_DATA_SIZE*MULTITHREAD]; +#endif + /* first call any initializations needed */ + portable_init(&(results[0].port), &argc, argv); + /* First some checks to make sure benchmark will run ok */ + if (sizeof(struct list_head_s)>128) { + ee_printf("list_head structure too big for comparable data!\n"); + return MAIN_RETURN_VAL; + } + results[0].seed1=get_seed(1); + results[0].seed2=get_seed(2); + results[0].seed3=get_seed(3); + results[0].iterations=get_seed_32(4); +#if CORE_DEBUG + results[0].iterations=1; +#endif + results[0].execs=get_seed_32(5); + if (results[0].execs==0) { /* if not supplied, execute all algorithms */ + results[0].execs=ALL_ALGORITHMS_MASK; + } + /* put in some default values based on one seed only for easy testing */ + if ((results[0].seed1==0) && (results[0].seed2==0) && (results[0].seed3==0)) { /* validation run */ + results[0].seed1=0; + results[0].seed2=0; + results[0].seed3=0x66; + } + if ((results[0].seed1==1) && (results[0].seed2==0) && (results[0].seed3==0)) { /* perfromance run */ + results[0].seed1=0x3415; + results[0].seed2=0x3415; + results[0].seed3=0x66; + } +#if (MEM_METHOD==MEM_STATIC) + results[0].memblock[0]=(void *)static_memblk; + results[0].size=TOTAL_DATA_SIZE; + results[0].err=0; + #if (MULTITHREAD>1) + #error "Cannot use a static data area with multiple contexts!" + #endif +#elif (MEM_METHOD==MEM_MALLOC) + for (i=0 ; i1) + if (default_num_contexts>MULTITHREAD) { + default_num_contexts=MULTITHREAD; + } + for (i=0 ; i=0) { + for (i=0 ; i 0) + ee_printf("Iterations/Sec : %f\n",default_num_contexts*results[0].iterations/time_in_secs(total_time)); +#else + ee_printf("Total time (secs): %d\n",time_in_secs(total_time)); + if (time_in_secs(total_time) > 0) + ee_printf("Iterations/Sec : %d\n",default_num_contexts*results[0].iterations/time_in_secs(total_time)); +#endif + if (time_in_secs(total_time) < 10) { + ee_printf("ERROR! Must execute for at least 10 secs for a valid result!\n"); + total_errors++; + } + + ee_printf("Iterations : %lu\n",(ee_u32)default_num_contexts*results[0].iterations); + ee_printf("Compiler version : %s\n",COMPILER_VERSION); + ee_printf("Compiler flags : %s\n",COMPILER_FLAGS); +#if (MULTITHREAD>1) + ee_printf("Parallel %s : %d\n",PARALLEL_METHOD,default_num_contexts); +#endif + ee_printf("Memory location : %s\n",MEM_LOCATION); + /* output for verification */ + ee_printf("seedcrc : 0x%04x\n",seedcrc); + if (results[0].execs & ID_LIST) + for (i=0 ; i1) + ee_printf(" / %d:%s",default_num_contexts,PARALLEL_METHOD); +#endif + ee_printf("\n"); + } +#endif + } + if (total_errors>0) + ee_printf("Errors detected\n"); + if (total_errors<0) + ee_printf("Cannot validate operation for these seed values, please compare with results on a known platform.\n"); + +#if (MEM_METHOD==MEM_MALLOC) + for (i=0 ; i>(from)) & (~(0xffffffff << (to)))) + +#if CORE_DEBUG +void printmat(MATDAT *A, ee_u32 N, char *name) { + ee_u32 i,j; + ee_printf("Matrix %s [%dx%d]:\n",name,N,N); + for (i=0; i N times, + changing the matrix values slightly by a constant amount each time. +*/ +ee_u16 core_bench_matrix(mat_params *p, ee_s16 seed, ee_u16 crc) { + ee_u32 N=p->N; + MATRES *C=p->C; + MATDAT *A=p->A; + MATDAT *B=p->B; + MATDAT val=(MATDAT)seed; + + crc=crc16(matrix_test(N,C,A,B,val),crc); + + return crc; +} + +/* Function: matrix_test + Perform matrix manipulation. + + Parameters: + N - Dimensions of the matrix. + C - memory for result matrix. + A - input matrix + B - operator matrix (not changed during operations) + + Returns: + A CRC value that captures all results calculated in the function. + In particular, crc of the value calculated on the result matrix + after each step by . + + Operation: + + 1 - Add a constant value to all elements of a matrix. + 2 - Multiply a matrix by a constant. + 3 - Multiply a matrix by a vector. + 4 - Multiply a matrix by a matrix. + 5 - Add a constant value to all elements of a matrix. + + After the last step, matrix A is back to original contents. +*/ +ee_s16 matrix_test(ee_u32 N, MATRES *C, MATDAT *A, MATDAT *B, MATDAT val) { + ee_u16 crc=0; + MATDAT clipval=matrix_big(val); + + matrix_add_const(N,A,val); /* make sure data changes */ +#if CORE_DEBUG + printmat(A,N,"matrix_add_const"); +#endif + matrix_mul_const(N,C,A,val); + crc=crc16(matrix_sum(N,C,clipval),crc); +#if CORE_DEBUG + printmatC(C,N,"matrix_mul_const"); +#endif + matrix_mul_vect(N,C,A,B); + crc=crc16(matrix_sum(N,C,clipval),crc); +#if CORE_DEBUG + printmatC(C,N,"matrix_mul_vect"); +#endif + matrix_mul_matrix(N,C,A,B); + crc=crc16(matrix_sum(N,C,clipval),crc); +#if CORE_DEBUG + printmatC(C,N,"matrix_mul_matrix"); +#endif + matrix_mul_matrix_bitextract(N,C,A,B); + crc=crc16(matrix_sum(N,C,clipval),crc); +#if CORE_DEBUG + printmatC(C,N,"matrix_mul_matrix_bitextract"); +#endif + + matrix_add_const(N,A,-val); /* return matrix to initial value */ + return crc; +} + +/* Function : matrix_init + Initialize the memory block for matrix benchmarking. + + Parameters: + blksize - Size of memory to be initialized. + memblk - Pointer to memory block. + seed - Actual values chosen depend on the seed parameter. + p - pointers to containing initialized matrixes. + + Returns: + Matrix dimensions. + + Note: + The seed parameter MUST be supplied from a source that cannot be determined at compile time +*/ +ee_u32 core_init_matrix(ee_u32 blksize, void *memblk, ee_s32 seed, mat_params *p) { + ee_u32 N=0; + MATDAT *A; + MATDAT *B; + ee_s32 order=1; + MATDAT val; + ee_u32 i=0,j=0; + if (seed==0) + seed=1; + while (jA=A; + p->B=B; + p->C=(MATRES *)align_mem(B+N*N); + p->N=N; +#if CORE_DEBUG + printmat(A,N,"A"); + printmat(B,N,"B"); +#endif + return N; +} + +/* Function: matrix_sum + Calculate a function that depends on the values of elements in the matrix. + + For each element, accumulate into a temporary variable. + + As long as this value is under the parameter clipval, + add 1 to the result if the element is bigger then the previous. + + Otherwise, reset the accumulator and add 10 to the result. +*/ +ee_s16 matrix_sum(ee_u32 N, MATRES *C, MATDAT clipval) { + MATRES tmp=0,prev=0,cur=0; + ee_s16 ret=0; + ee_u32 i,j; + for (i=0; iclipval) { + ret+=10; + tmp=0; + } else { + ret += (cur>prev) ? 1 : 0; + } + prev=cur; + } + } + return ret; +} + +/* Function: matrix_mul_const + Multiply a matrix by a constant. + This could be used as a scaler for instance. +*/ +void matrix_mul_const(ee_u32 N, MATRES *C, MATDAT *A, MATDAT val) { + ee_u32 i,j; + for (i=0; i0) { + for(i=0;i>3) & 0x3]; + next=4; + break; + case 3: /* float */ + case 4: /* float */ + buf=floatpat[(seed>>3) & 0x3]; + next=8; + break; + case 5: /* scientific */ + case 6: /* scientific */ + buf=scipat[(seed>>3) & 0x3]; + next=8; + break; + case 7: /* invalid */ + buf=errpat[(seed>>3) & 0x3]; + next=8; + break; + default: /* Never happen, just to make some compilers happy */ + break; + } + } + size++; + while (total='0') & (c<='9')) ? 1 : 0; + return retval; +} + +/* Function: core_state_transition + Actual state machine. + + The state machine will continue scanning until either: + 1 - an invalid input is detcted. + 2 - a valid number has been detected. + + The input pointer is updated to point to the end of the token, and the end state is returned (either specific format determined or invalid). +*/ + +enum CORE_STATE core_state_transition( ee_u8 **instr , ee_u32 *transition_count) { + ee_u8 *str=*instr; + ee_u8 NEXT_SYMBOL; + enum CORE_STATE state=CORE_START; + for( ; *str && state != CORE_INVALID; str++ ) { + NEXT_SYMBOL = *str; + if (NEXT_SYMBOL==',') /* end of this input */ { + str++; + break; + } + switch(state) { + case CORE_START: + if(ee_isdigit(NEXT_SYMBOL)) { + state = CORE_INT; + } + else if( NEXT_SYMBOL == '+' || NEXT_SYMBOL == '-' ) { + state = CORE_S1; + } + else if( NEXT_SYMBOL == '.' ) { + state = CORE_FLOAT; + } + else { + state = CORE_INVALID; + transition_count[CORE_INVALID]++; + } + transition_count[CORE_START]++; + break; + case CORE_S1: + if(ee_isdigit(NEXT_SYMBOL)) { + state = CORE_INT; + transition_count[CORE_S1]++; + } + else if( NEXT_SYMBOL == '.' ) { + state = CORE_FLOAT; + transition_count[CORE_S1]++; + } + else { + state = CORE_INVALID; + transition_count[CORE_S1]++; + } + break; + case CORE_INT: + if( NEXT_SYMBOL == '.' ) { + state = CORE_FLOAT; + transition_count[CORE_INT]++; + } + else if(!ee_isdigit(NEXT_SYMBOL)) { + state = CORE_INVALID; + transition_count[CORE_INT]++; + } + break; + case CORE_FLOAT: + if( NEXT_SYMBOL == 'E' || NEXT_SYMBOL == 'e' ) { + state = CORE_S2; + transition_count[CORE_FLOAT]++; + } + else if(!ee_isdigit(NEXT_SYMBOL)) { + state = CORE_INVALID; + transition_count[CORE_FLOAT]++; + } + break; + case CORE_S2: + if( NEXT_SYMBOL == '+' || NEXT_SYMBOL == '-' ) { + state = CORE_EXPONENT; + transition_count[CORE_S2]++; + } + else { + state = CORE_INVALID; + transition_count[CORE_S2]++; + } + break; + case CORE_EXPONENT: + if(ee_isdigit(NEXT_SYMBOL)) { + state = CORE_SCIENTIFIC; + transition_count[CORE_EXPONENT]++; + } + else { + state = CORE_INVALID; + transition_count[CORE_EXPONENT]++; + } + break; + case CORE_SCIENTIFIC: + if(!ee_isdigit(NEXT_SYMBOL)) { + state = CORE_INVALID; + transition_count[CORE_INVALID]++; + } + break; + default: + break; + } + } + *instr=str; + return state; +} diff --git a/core_util.c b/core_util.c new file mode 100644 index 0000000..0b95bfe --- /dev/null +++ b/core_util.c @@ -0,0 +1,210 @@ +/* +Author : Shay Gal-On, EEMBC + +This file is part of EEMBC(R) and CoreMark(TM), which are Copyright (C) 2009 +All rights reserved. + +EEMBC CoreMark Software is a product of EEMBC and is provided under the terms of the +CoreMark License that is distributed with the official EEMBC COREMARK Software release. +If you received this EEMBC CoreMark Software without the accompanying CoreMark License, +you must discontinue use and download the official release from www.coremark.org. + +Also, if you are publicly displaying scores generated from the EEMBC CoreMark software, +make sure that you are in compliance with Run and Reporting rules specified in the accompanying readme.txt file. + +EEMBC +4354 Town Center Blvd. Suite 114-200 +El Dorado Hills, CA, 95762 +*/ +#include "coremark.h" +/* Function: get_seed + Get a values that cannot be determined at compile time. + + Since different embedded systems and compilers are used, 3 different methods are provided: + 1 - Using a volatile variable. This method is only valid if the compiler is forced to generate code that + reads the value of a volatile variable from memory at run time. + Please note, if using this method, you would need to modify core_portme.c to generate training profile. + 2 - Command line arguments. This is the preferred method if command line arguments are supported. + 3 - System function. If none of the first 2 methods is available on the platform, + a system function which is not a stub can be used. + + e.g. read the value on GPIO pins connected to switches, or invoke special simulator functions. +*/ +#if (SEED_METHOD==SEED_VOLATILE) + extern volatile ee_s32 seed1_volatile; + extern volatile ee_s32 seed2_volatile; + extern volatile ee_s32 seed3_volatile; + extern volatile ee_s32 seed4_volatile; + extern volatile ee_s32 seed5_volatile; + ee_s32 get_seed_32(int i) { + ee_s32 retval; + switch (i) { + case 1: + retval=seed1_volatile; + break; + case 2: + retval=seed2_volatile; + break; + case 3: + retval=seed3_volatile; + break; + case 4: + retval=seed4_volatile; + break; + case 5: + retval=seed5_volatile; + break; + default: + retval=0; + break; + } + return retval; + } +#elif (SEED_METHOD==SEED_ARG) +ee_s32 parseval(char *valstring) { + ee_s32 retval=0; + ee_s32 neg=1; + int hexmode=0; + if (*valstring == '-') { + neg=-1; + valstring++; + } + if ((valstring[0] == '0') && (valstring[1] == 'x')) { + hexmode=1; + valstring+=2; + } + /* first look for digits */ + if (hexmode) { + while (((*valstring >= '0') && (*valstring <= '9')) || ((*valstring >= 'a') && (*valstring <= 'f'))) { + ee_s32 digit=*valstring-'0'; + if (digit>9) + digit=10+*valstring-'a'; + retval*=16; + retval+=digit; + valstring++; + } + } else { + while ((*valstring >= '0') && (*valstring <= '9')) { + ee_s32 digit=*valstring-'0'; + retval*=10; + retval+=digit; + valstring++; + } + } + /* now add qualifiers */ + if (*valstring=='K') + retval*=1024; + if (*valstring=='M') + retval*=1024*1024; + + retval*=neg; + return retval; +} + +ee_s32 get_seed_args(int i, int argc, char *argv[]) { + if (argc>i) + return parseval(argv[i]); + return 0; +} + +#elif (SEED_METHOD==SEED_FUNC) +/* If using OS based function, you must define and implement the functions below in core_portme.h and core_portme.c ! */ +ee_s32 get_seed_32(int i) { + ee_s32 retval; + switch (i) { + case 1: + retval=portme_sys1(); + break; + case 2: + retval=portme_sys2(); + break; + case 3: + retval=portme_sys3(); + break; + case 4: + retval=portme_sys4(); + break; + case 5: + retval=portme_sys5(); + break; + default: + retval=0; + break; + } + return retval; +} +#endif + +/* Function: crc* + Service functions to calculate 16b CRC code. + +*/ +ee_u16 crcu8(ee_u8 data, ee_u16 crc ) +{ + ee_u8 i=0,x16=0,carry=0; + + for (i = 0; i < 8; i++) + { + x16 = (ee_u8)((data & 1) ^ ((ee_u8)crc & 1)); + data >>= 1; + + if (x16 == 1) + { + crc ^= 0x4002; + carry = 1; + } + else + carry = 0; + crc >>= 1; + if (carry) + crc |= 0x8000; + else + crc &= 0x7fff; + } + return crc; +} +ee_u16 crcu16(ee_u16 newval, ee_u16 crc) { + crc=crcu8( (ee_u8) (newval) ,crc); + crc=crcu8( (ee_u8) ((newval)>>8) ,crc); + return crc; +} +ee_u16 crcu32(ee_u32 newval, ee_u16 crc) { + crc=crc16((ee_s16) newval ,crc); + crc=crc16((ee_s16) (newval>>16) ,crc); + return crc; +} +ee_u16 crc16(ee_s16 newval, ee_u16 crc) { + return crcu16((ee_u16)newval, crc); +} + +ee_u8 check_data_types() { + ee_u8 retval=0; + if (sizeof(ee_u8) != 1) { + ee_printf("ERROR: ee_u8 is not an 8b datatype!\n"); + retval++; + } + if (sizeof(ee_u16) != 2) { + ee_printf("ERROR: ee_u16 is not a 16b datatype!\n"); + retval++; + } + if (sizeof(ee_s16) != 2) { + ee_printf("ERROR: ee_s16 is not a 16b datatype!\n"); + retval++; + } + if (sizeof(ee_s32) != 4) { + ee_printf("ERROR: ee_s32 is not a 32b datatype!\n"); + retval++; + } + if (sizeof(ee_u32) != 4) { + ee_printf("ERROR: ee_u32 is not a 32b datatype!\n"); + retval++; + } + if (sizeof(ee_ptr_int) != sizeof(int *)) { + ee_printf("ERROR: ee_ptr_int is not a datatype that holds an int pointer!\n"); + retval++; + } + if (retval>0) { + ee_printf("ERROR: Please modify the datatypes in core_portme.h!\n"); + } + return retval; +} diff --git a/coremark.h b/coremark.h new file mode 100644 index 0000000..90c0f36 --- /dev/null +++ b/coremark.h @@ -0,0 +1,174 @@ +/* +Author : Shay Gal-On, EEMBC + +This file is part of EEMBC(R) and CoreMark(TM), which are Copyright (C) 2009 +All rights reserved. + +EEMBC CoreMark Software is a product of EEMBC and is provided under the terms of the +CoreMark License that is distributed with the official EEMBC COREMARK Software release. +If you received this EEMBC CoreMark Software without the accompanying CoreMark License, +you must discontinue use and download the official release from www.coremark.org. + +Also, if you are publicly displaying scores generated from the EEMBC CoreMark software, +make sure that you are in compliance with Run and Reporting rules specified in the accompanying readme.txt file. + +EEMBC +4354 Town Center Blvd. Suite 114-200 +El Dorado Hills, CA, 95762 +*/ +/* Topic: Description + This file contains declarations of the various benchmark functions. +*/ + +/* Configuration: TOTAL_DATA_SIZE + Define total size for data algorithms will operate on +*/ +#ifndef TOTAL_DATA_SIZE +#define TOTAL_DATA_SIZE 2*1000 +#endif + +#define SEED_ARG 0 +#define SEED_FUNC 1 +#define SEED_VOLATILE 2 + +#define MEM_STATIC 0 +#define MEM_MALLOC 1 +#define MEM_STACK 2 + +#include "core_portme.h" + +#if HAS_STDIO +#include +#endif +#if HAS_PRINTF +#define ee_printf printf +#endif + +/* Actual benchmark execution in iterate */ +void *iterate(void *pres); + +/* Typedef: secs_ret + For machines that have floating point support, get number of seconds as a double. + Otherwise an unsigned int. +*/ +#if HAS_FLOAT +typedef double secs_ret; +#else +typedef ee_u32 secs_ret; +#endif + +#if MAIN_HAS_NORETURN +#define MAIN_RETURN_VAL +#define MAIN_RETURN_TYPE void +#else +#define MAIN_RETURN_VAL 0 +#define MAIN_RETURN_TYPE int +#endif + +void start_time(void); +void stop_time(void); +CORE_TICKS get_time(void); +secs_ret time_in_secs(CORE_TICKS ticks); + +/* Misc useful functions */ +ee_u16 crcu8(ee_u8 data, ee_u16 crc); +ee_u16 crc16(ee_s16 newval, ee_u16 crc); +ee_u16 crcu16(ee_u16 newval, ee_u16 crc); +ee_u16 crcu32(ee_u32 newval, ee_u16 crc); +ee_u8 check_data_types(); +void *portable_malloc(ee_size_t size); +void portable_free(void *p); +ee_s32 parseval(char *valstring); + +/* Algorithm IDS */ +#define ID_LIST (1<<0) +#define ID_MATRIX (1<<1) +#define ID_STATE (1<<2) +#define ALL_ALGORITHMS_MASK (ID_LIST|ID_MATRIX|ID_STATE) +#define NUM_ALGORITHMS 3 + +/* list data structures */ +typedef struct list_data_s { + ee_s16 data16; + ee_s16 idx; +} list_data; + +typedef struct list_head_s { + struct list_head_s *next; + struct list_data_s *info; +} list_head; + + +/*matrix benchmark related stuff */ +#define MATDAT_INT 1 +#if MATDAT_INT +typedef ee_s16 MATDAT; +typedef ee_s32 MATRES; +#else +typedef ee_f16 MATDAT; +typedef ee_f32 MATRES; +#endif + +typedef struct MAT_PARAMS_S { + int N; + MATDAT *A; + MATDAT *B; + MATRES *C; +} mat_params; + +/* state machine related stuff */ +/* List of all the possible states for the FSM */ +typedef enum CORE_STATE { + CORE_START=0, + CORE_INVALID, + CORE_S1, + CORE_S2, + CORE_INT, + CORE_FLOAT, + CORE_EXPONENT, + CORE_SCIENTIFIC, + NUM_CORE_STATES +} core_state_e ; + + +/* Helper structure to hold results */ +typedef struct RESULTS_S { + /* inputs */ + ee_s16 seed1; /* Initializing seed */ + ee_s16 seed2; /* Initializing seed */ + ee_s16 seed3; /* Initializing seed */ + void *memblock[4]; /* Pointer to safe memory location */ + ee_u32 size; /* Size of the data */ + ee_u32 iterations; /* Number of iterations to execute */ + ee_u32 execs; /* Bitmask of operations to execute */ + struct list_head_s *list; + mat_params mat; + /* outputs */ + ee_u16 crc; + ee_u16 crclist; + ee_u16 crcmatrix; + ee_u16 crcstate; + ee_s16 err; + /* ultithread specific */ + core_portable port; +} core_results; + +/* Multicore execution handling */ +#if (MULTITHREAD>1) +ee_u8 core_start_parallel(core_results *res); +ee_u8 core_stop_parallel(core_results *res); +#endif + +/* list benchmark functions */ +list_head *core_list_init(ee_u32 blksize, list_head *memblock, ee_s16 seed); +ee_u16 core_bench_list(core_results *res, ee_s16 finder_idx); + +/* state benchmark functions */ +void core_init_state(ee_u32 size, ee_s16 seed, ee_u8 *p); +ee_u16 core_bench_state(ee_u32 blksize, ee_u8 *memblock, + ee_s16 seed1, ee_s16 seed2, ee_s16 step, ee_u16 crc); + +/* matrix benchmark functions */ +ee_u32 core_init_matrix(ee_u32 blksize, void *memblk, ee_s32 seed, mat_params *p); +ee_u16 core_bench_matrix(mat_params *p, ee_s16 seed, ee_u16 crc); + diff --git a/cygwin/core_portme.c b/cygwin/core_portme.c new file mode 100755 index 0000000..10e8f40 --- /dev/null +++ b/cygwin/core_portme.c @@ -0,0 +1,325 @@ +/* + File: core_portme.c +*/ +/* + Author : Shay Gal-On, EEMBC + Legal : TODO! +*/ +#include +#include +#include "coremark.h" +#if CALLGRIND_RUN +#include +#endif + +#if (MEM_METHOD==MEM_MALLOC) +#include +/* Function: portable_malloc + Provide malloc() functionality in a platform specific way. +*/ +void *portable_malloc(size_t size) { + return malloc(size); +} +/* Function: portable_free + Provide free() functionality in a platform specific way. +*/ +void portable_free(void *p) { + free(p); +} +#else +void *portable_malloc(size_t size) { + return NULL; +} +void portable_free(void *p) { + p=NULL; +} +#endif + +#if (SEED_METHOD==SEED_VOLATILE) +#if VALIDATION_RUN + volatile ee_s32 seed1_volatile=0x3415; + volatile ee_s32 seed2_volatile=0x3415; + volatile ee_s32 seed3_volatile=0x66; +#endif +#if PERFORMANCE_RUN + volatile ee_s32 seed1_volatile=0x0; + volatile ee_s32 seed2_volatile=0x0; + volatile ee_s32 seed3_volatile=0x66; +#endif +#if PROFILE_RUN + volatile ee_s32 seed1_volatile=0x8; + volatile ee_s32 seed2_volatile=0x8; + volatile ee_s32 seed3_volatile=0x8; +#endif + volatile ee_s32 seed4_volatile=ITERATIONS; + volatile ee_s32 seed5_volatile=0; +#endif +/* Porting: Timing functions + How to capture time and convert to seconds must be ported to whatever is supported by the platform. + e.g. Read value from on board RTC, read value from cpu clock cycles performance counter etc. + Sample implementation for standard time.h and windows.h definitions included. +*/ +/* Define: TIMER_RES_DIVIDER + Divider to trade off timer resolution and total time that can be measured. + + Use lower values to increase resolution, but make sure that overflow does not occur. + If there are issues with the return value overflowing, increase this value. + */ +#if USE_CLOCK + #define NSECS_PER_SEC CLOCKS_PER_SEC + #define EE_TIMER_TICKER_RATE 1000 + #define CORETIMETYPE clock_t + #define GETMYTIME(_t) (*_t=clock()) + #define MYTIMEDIFF(fin,ini) ((fin)-(ini)) + #define TIMER_RES_DIVIDER 1 + #define SAMPLE_TIME_IMPLEMENTATION 1 +#elif defined(_MSC_VER) + #define NSECS_PER_SEC 10000000 + #define EE_TIMER_TICKER_RATE 1000 + #define CORETIMETYPE FILETIME + #define GETMYTIME(_t) GetSystemTimeAsFileTime(_t) + #define MYTIMEDIFF(fin,ini) (((*(__int64*)&fin)-(*(__int64*)&ini))/TIMER_RES_DIVIDER) + /* setting to millisces resolution by default with MSDEV */ + #ifndef TIMER_RES_DIVIDER + #define TIMER_RES_DIVIDER 1000 + #endif + #define SAMPLE_TIME_IMPLEMENTATION 1 +#elif HAS_TIME_H + #define NSECS_PER_SEC 1000000000 + #define EE_TIMER_TICKER_RATE 1000 + #define CORETIMETYPE struct timespec + #define GETMYTIME(_t) clock_gettime(CLOCK_REALTIME,_t) + #define MYTIMEDIFF(fin,ini) ((fin.tv_sec-ini.tv_sec)*(NSECS_PER_SEC/TIMER_RES_DIVIDER)+(fin.tv_nsec-ini.tv_nsec)/TIMER_RES_DIVIDER) + /* setting to 1/1000 of a second resolution by default with linux */ + #ifndef TIMER_RES_DIVIDER + #define TIMER_RES_DIVIDER 1000000 + #endif + #define SAMPLE_TIME_IMPLEMENTATION 1 +#else + #define SAMPLE_TIME_IMPLEMENTATION 0 +#endif +#define EE_TICKS_PER_SEC (NSECS_PER_SEC / TIMER_RES_DIVIDER) + +#if SAMPLE_TIME_IMPLEMENTATION +/** Define Host specific (POSIX), or target specific global time variables. */ +static CORETIMETYPE start_time_val, stop_time_val; + +/* Function: start_time + This function will be called right before starting the timed portion of the benchmark. + + Implementation may be capturing a system timer (as implemented in the example code) + or zeroing some system parameters - e.g. setting the cpu clocks cycles to 0. +*/ +void start_time(void) { + GETMYTIME(&start_time_val ); +#if CALLGRIND_RUN + CALLGRIND_START_INSTRUMENTATION +#endif +#if MICA + asm volatile("int3");/*1 */ +#endif +} +/* Function: stop_time + This function will be called right after ending the timed portion of the benchmark. + + Implementation may be capturing a system timer (as implemented in the example code) + or other system parameters - e.g. reading the current value of cpu cycles counter. +*/ +void stop_time(void) { +#if CALLGRIND_RUN + CALLGRIND_STOP_INSTRUMENTATION +#endif +#if MICA + asm volatile("int3");/*1 */ +#endif + GETMYTIME(&stop_time_val ); +} +/* Function: get_time + Return an abstract "ticks" number that signifies time on the system. + + Actual value returned may be cpu cycles, milliseconds or any other value, + as long as it can be converted to seconds by . + This methodology is taken to accomodate any hardware or simulated platform. + The sample implementation returns millisecs by default, + and the resolution is controlled by +*/ +CORE_TICKS get_time(void) { + CORE_TICKS elapsed=(CORE_TICKS)(MYTIMEDIFF(stop_time_val, start_time_val)); + return elapsed; +} +/* Function: time_in_secs + Convert the value returned by get_time to seconds. + + The type is used to accomodate systems with no support for floating point. + Default implementation implemented by the EE_TICKS_PER_SEC macro above. +*/ +secs_ret time_in_secs(CORE_TICKS ticks) { + secs_ret retval=((secs_ret)ticks) / (secs_ret)EE_TICKS_PER_SEC; + return retval; +} +#else +#error "Please implement timing functionality in core_portme.c" +#endif /* SAMPLE_TIME_IMPLEMENTATION */ + +ee_u32 default_num_contexts=MULTITHREAD; + +/* Function: portable_init + Target specific initialization code + Test for some common mistakes. +*/ +void portable_init(core_portable *p, int *argc, char *argv[]) +{ +#if PRINT_ARGS + int i; + for (i=0; i<*argc; i++) { + ee_printf("Arg[%d]=%s\n",i,argv[i]); + } +#endif + if (sizeof(ee_ptr_int) != sizeof(ee_u8 *)) { + ee_printf("ERROR! Please define ee_ptr_int to a type that holds a pointer!\n"); + } + if (sizeof(ee_u32) != 4) { + ee_printf("ERROR! Please define ee_u32 to a 32b unsigned type!\n"); + } +#if (MAIN_HAS_NOARGC && (SEED_METHOD==SEED_ARG)) + ee_printf("ERROR! Main has no argc, but SEED_METHOD defined to SEED_ARG!\n"); +#endif + +#if (MULTITHREAD>1) && (SEED_METHOD==SEED_ARG) + int nargs=*argc,i; + if ((nargs>1) && (*argv[1]=='M')) { + default_num_contexts=parseval(argv[1]+1); + if (default_num_contexts>MULTITHREAD) + default_num_contexts=MULTITHREAD; + /* Shift args since first arg is directed to the portable part and not to coremark main */ + --nargs; + for (i=1; i*/ + p->portable_id=1; +} +/* Function: portable_fini + Target specific final code +*/ +void portable_fini(core_portable *p) +{ + p->portable_id=0; +} + +#if (MULTITHREAD>1) + +/* Function: core_start_parallel + Start benchmarking in a parallel context. + + Three implementations are provided, one using pthreads, one using fork and shared mem, and one using fork and sockets. + Other implementations using MCAPI or other standards can easily be devised. +*/ +/* Function: core_stop_parallel + Stop a parallel context execution of coremark, and gather the results. + + Three implementations are provided, one using pthreads, one using fork and shared mem, and one using fork and sockets. + Other implementations using MCAPI or other standards can easily be devised. +*/ +#if USE_PTHREAD +ee_u8 core_start_parallel(core_results *res) { + return (ee_u8)pthread_create(&(res->port.thread),NULL,iterate,(void *)res); +} +ee_u8 core_stop_parallel(core_results *res) { + void *retval; + return (ee_u8)pthread_join(res->port.thread,&retval); +} +#elif USE_FORK +static int key_id=0; +ee_u8 core_start_parallel(core_results *res) { + key_t key=4321+key_id; + key_id++; + res->port.pid=fork(); + res->port.shmid=shmget(key, 8, IPC_CREAT | 0666); + if (res->port.shmid<0) { + ee_printf("ERROR in shmget!\n"); + } + if (res->port.pid==0) { + iterate(res); + res->port.shm=shmat(res->port.shmid, NULL, 0); + /* copy the validation values to the shared memory area and quit*/ + if (res->port.shm == (char *) -1) { + ee_printf("ERROR in child shmat!\n"); + } else { + memcpy(res->port.shm,&(res->crc),8); + shmdt(res->port.shm); + } + exit(0); + } + return 1; +} +ee_u8 core_stop_parallel(core_results *res) { + int status; + pid_t wpid = waitpid(res->port.pid,&status,WUNTRACED); + if (wpid != res->port.pid) { + ee_printf("ERROR waiting for child.\n"); + if (errno == ECHILD) ee_printf("errno=No such child %d\n",res->port.pid); + if (errno == EINTR) ee_printf("errno=Interrupted\n"); + return 0; + } + /* after process is done, get the values from the shared memory area */ + res->port.shm=shmat(res->port.shmid, NULL, 0); + if (res->port.shm == (char *) -1) { + ee_printf("ERROR in parent shmat!\n"); + return 0; + } + memcpy(&(res->crc),res->port.shm,8); + shmdt(res->port.shm); + return 1; +} +#elif USE_SOCKET +static int key_id=0; +ee_u8 core_start_parallel(core_results *res) { + int bound, buffer_length=8; + res->port.sa.sin_family = AF_INET; + res->port.sa.sin_addr.s_addr = htonl(0x7F000001); + res->port.sa.sin_port = htons(7654+key_id); + key_id++; + res->port.pid=fork(); + if (res->port.pid==0) { /* benchmark child */ + iterate(res); + res->port.sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP); + if (-1 == res->port.sock) /* if socket failed to initialize, exit */ { + ee_printf("Error Creating Socket"); + } else { + int bytes_sent = sendto(res->port.sock, &(res->crc), buffer_length, 0,(struct sockaddr*)&(res->port.sa), sizeof (struct sockaddr_in)); + if (bytes_sent < 0) + ee_printf("Error sending packet: %s\n", strerror(errno)); + close(res->port.sock); /* close the socket */ + } + exit(0); + } + /* parent process, open the socket */ + res->port.sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP); + bound = bind(res->port.sock,(struct sockaddr*)&(res->port.sa), sizeof(struct sockaddr)); + if (bound < 0) + ee_printf("bind(): %s\n",strerror(errno)); + return 1; +} +ee_u8 core_stop_parallel(core_results *res) { + int status; + int fromlen=sizeof(struct sockaddr); + int recsize = recvfrom(res->port.sock, &(res->crc), 8, 0, (struct sockaddr*)&(res->port.sa), &fromlen); + if (recsize < 0) { + ee_printf("Error in receive: %s\n", strerror(errno)); + return 0; + } + pid_t wpid = waitpid(res->port.pid,&status,WUNTRACED); + if (wpid != res->port.pid) { + ee_printf("ERROR waiting for child.\n"); + if (errno == ECHILD) ee_printf("errno=No such child %d\n",res->port.pid); + if (errno == EINTR) ee_printf("errno=Interrupted\n"); + return 0; + } + return 1; +} +#else /* no standard multicore implementation */ +#error "Please implement multicore functionality in core_portme.c to use multiple contexts." +#endif /* multithread implementations */ +#endif diff --git a/cygwin/core_portme.h b/cygwin/core_portme.h new file mode 100755 index 0000000..a7642bc --- /dev/null +++ b/cygwin/core_portme.h @@ -0,0 +1,281 @@ +/* File: core_portme.h */ + +/* + Author : Shay Gal-On, EEMBC + Legal : TODO! +*/ +/* Topic: Description + This file contains configuration constants required to execute on different platforms +*/ +#ifndef CORE_PORTME_H +#define CORE_PORTME_H +/************************/ +/* Data types and settings */ +/************************/ +/* Configuration: HAS_FLOAT + Define to 1 if the platform supports floating point. +*/ +#ifndef HAS_FLOAT +#define HAS_FLOAT 1 +#endif +/* Configuration: HAS_TIME_H + Define to 1 if platform has the time.h header file, + and implementation of functions thereof. +*/ +#ifndef HAS_TIME_H +#define HAS_TIME_H 1 +#endif +/* Configuration: USE_CLOCK + Define to 1 if platform has the time.h header file, + and implementation of functions thereof. +*/ +#ifndef USE_CLOCK +#define USE_CLOCK 0 +#endif +/* Configuration: HAS_STDIO + Define to 1 if the platform has stdio.h. +*/ +#ifndef HAS_STDIO +#define HAS_STDIO 1 +#endif +/* Configuration: HAS_PRINTF + Define to 1 if the platform has stdio.h and implements the printf function. +*/ +#ifndef HAS_PRINTF +#define HAS_PRINTF 1 +#endif + +/* Configuration: CORE_TICKS + Define type of return from the timing functions. + */ +#if defined(_MSC_VER) +#include +typedef size_t CORE_TICKS; +#elif HAS_TIME_H +#include +typedef clock_t CORE_TICKS; +#else +#error "Please define type of CORE_TICKS and implement start_time, end_time get_time and time_in_secs functions!" +#endif + +/* Definitions: COMPILER_VERSION, COMPILER_FLAGS, MEM_LOCATION + Initialize these strings per platform +*/ +#ifndef COMPILER_VERSION + #ifdef __GNUC__ + #define COMPILER_VERSION "GCC"__VERSION__ + #else + #define COMPILER_VERSION "Please put compiler version here (e.g. gcc 4.1)" + #endif +#endif +#ifndef COMPILER_FLAGS + #define COMPILER_FLAGS FLAGS_STR /* "Please put compiler flags here (e.g. -o3)" */ +#endif +#ifndef MEM_LOCATION + #define MEM_LOCATION "Please put data memory location here\n\t\t\t(e.g. code in flash, data on heap etc)" + #define MEM_LOCATION_UNSPEC 1 +#endif + +/* Data Types: + To avoid compiler issues, define the data types that need ot be used for 8b, 16b and 32b in . + + *Imprtant*: + ee_ptr_int needs to be the data type used to hold pointers, otherwise coremark may fail!!! +*/ +typedef signed short ee_s16; +typedef unsigned short ee_u16; +typedef signed int ee_s32; +typedef double ee_f32; +typedef unsigned char ee_u8; +typedef unsigned int ee_u32; +typedef ee_u32 ee_ptr_int; +typedef size_t ee_size_t; +/* align_mem: + This macro is used to align an offset to point to a 32b value. It is used in the Matrix algorithm to initialize the input memory blocks. +*/ +#define align_mem(x) (void *)(4 + (((ee_ptr_int)(x) - 1) & ~3)) + +/* Configuration: SEED_METHOD + Defines method to get seed values that cannot be computed at compile time. + + Valid values: + SEED_ARG - from command line. + SEED_FUNC - from a system function. + SEED_VOLATILE - from volatile variables. +*/ +#ifndef SEED_METHOD +#define SEED_METHOD SEED_ARG +#endif + +/* Configuration: MEM_METHOD + Defines method to get a block of memry. + + Valid values: + MEM_MALLOC - for platforms that implement malloc and have malloc.h. + MEM_STATIC - to use a static memory array. + MEM_STACK - to allocate the data block on the stack (NYI). +*/ +#ifndef MEM_METHOD +#define MEM_METHOD MEM_MALLOC +#endif + +/* Configuration: MULTITHREAD + Define for parallel execution + + Valid values: + 1 - only one context (default). + N>1 - will execute N copies in parallel. + + Note: + If this flag is defined to more then 1, an implementation for launching parallel contexts must be defined. + + Two sample implementations are provided. Use or to enable them. + + It is valid to have a different implementation of and in , + to fit a particular architecture. +*/ +#ifndef MULTITHREAD +#define MULTITHREAD 1 +#endif + +/* Configuration: USE_PTHREAD + Sample implementation for launching parallel contexts + This implementation uses pthread_thread_create and pthread_join. + + Valid values: + 0 - Do not use pthreads API. + 1 - Use pthreads API + + Note: + This flag only matters if MULTITHREAD has been defined to a value greater then 1. +*/ +#ifndef USE_PTHREAD +#define USE_PTHREAD 0 +#endif + +/* Configuration: USE_FORK + Sample implementation for launching parallel contexts + This implementation uses fork, waitpid, shmget,shmat and shmdt. + + Valid values: + 0 - Do not use fork API. + 1 - Use fork API + + Note: + This flag only matters if MULTITHREAD has been defined to a value greater then 1. +*/ +#ifndef USE_FORK +#define USE_FORK 0 +#endif + +/* Configuration: USE_SOCKET + Sample implementation for launching parallel contexts + This implementation uses fork, socket, sendto and recvfrom + + Valid values: + 0 - Do not use fork and sockets API. + 1 - Use fork and sockets API + + Note: + This flag only matters if MULTITHREAD has been defined to a value greater then 1. +*/ +#ifndef USE_SOCKET +#define USE_SOCKET 0 +#endif + +/* Configuration: MAIN_HAS_NOARGC + Needed if platform does not support getting arguments to main. + + Valid values: + 0 - argc/argv to main is supported + 1 - argc/argv to main is not supported +*/ +#ifndef MAIN_HAS_NOARGC +#define MAIN_HAS_NOARGC 0 +#endif + +/* Configuration: MAIN_HAS_NORETURN + Needed if platform does not support returning a value from main. + + Valid values: + 0 - main returns an int, and return value will be 0. + 1 - platform does not support returning a value from main +*/ +#ifndef MAIN_HAS_NORETURN +#define MAIN_HAS_NORETURN 0 +#endif + +/* Variable: default_num_contexts + Number of contexts to spawn in multicore context. + Override this global value to change number of contexts used. + + Note: + This value may not be set higher then the define. + + To experiment, you can set the define to the highest value expected, and use argc/argv in the to set this value from the command line. +*/ +extern ee_u32 default_num_contexts; + +#if (MULTITHREAD>1) +#if USE_PTHREAD + #include + #define PARALLEL_METHOD "PThreads" +#elif USE_FORK + #include + #include + #include + #include + #include /* for memcpy */ + #define PARALLEL_METHOD "Fork" +#elif USE_SOCKET + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #define PARALLEL_METHOD "Sockets" +#else + #define PARALLEL_METHOD "Proprietary" + #error "Please implement multicore functionality in core_portme.c to use multiple contexts." +#endif /* Method for multithreading */ +#endif /* MULTITHREAD > 1 */ + +typedef struct CORE_PORTABLE_S { +#if (MULTITHREAD>1) + #if USE_PTHREAD + pthread_t thread; + #elif USE_FORK + pid_t pid; + int shmid; + void *shm; + #elif USE_SOCKET + pid_t pid; + int sock; + struct sockaddr_in sa; + #endif /* Method for multithreading */ +#endif /* MULTITHREAD>1 */ + ee_u8 portable_id; +} core_portable; + +/* target specific init/fini */ +void portable_init(core_portable *p, int *argc, char *argv[]); +void portable_fini(core_portable *p); + +#if (SEED_METHOD==SEED_VOLATILE) + #if (VALIDATION_RUN || PERFORMANCE_RUN || PROFILE_RUN) + #define RUN_TYPE_FLAG 1 + #else + #if (TOTAL_DATA_SIZE==1200) + #define PROFILE_RUN 1 + #else + #define PERFORMANCE_RUN 1 + #endif + #endif +#endif /* SEED_METHOD==SEED_VOLATILE */ + +#endif /* CORE_PORTME_H */ diff --git a/cygwin/core_portme.mak b/cygwin/core_portme.mak new file mode 100755 index 0000000..207b35d --- /dev/null +++ b/cygwin/core_portme.mak @@ -0,0 +1,125 @@ +#File: core_portme.mak + +# Flag: OUTFLAG +# Use this flag to define how to to get an executable (e.g -o) +OUTFLAG= -o +# Flag: CC +# Use this flag to define compiler to use +CC = gcc +# Flag: CFLAGS +# Use this flag to define compiler options. Note, you can add compiler options from the command line using XCFLAGS="other flags" +PORT_CFLAGS = -O2 +FLAGS_STR = "$(PORT_CFLAGS) $(XCFLAGS) $(XLFLAGS) $(LFLAGS_END)" +CFLAGS = $(PORT_CFLAGS) -I$(PORT_DIR) -I. -DFLAGS_STR=\"$(FLAGS_STR)\" +#Flag: LFLAGS_END +# Define any libraries needed for linking or other flags that should come at the end of the link line (e.g. linker scripts). +# Note: On certain platforms, the default clock_gettime implementation is supported but requires linking of librt. +LFLAGS_END = +# Flag: PORT_SRCS +# Port specific source files can be added here +PORT_SRCS = $(PORT_DIR)/core_portme.c +# Flag: LOAD +# Define this flag if you need to load to a target, as in a cross compile environment. + +# Flag: RUN +# Define this flag if running does not consist of simple invocation of the binary. +# In a cross compile environment, you need to define this. + +#For flashing and using a tera term macro, you could use +#LOAD = flash ADDR +#RUN = ttpmacro coremark.ttl + +#For copying to target and executing via SSH connection, you could use +#LOAD = scp $(OUTFILE) user@target:~ +#RUN = ssh user@target -c + +#For native compilation and execution +LOAD = echo Loading done +RUN = + +OEXT = .o +EXE = .exe + +# Flag: SEPARATE_COMPILE +# Define if you need to separate compilation from link stage. +# In this case, you also need to define below how to create an object file, and how to link. +ifdef SEPARATE_COMPILE + +LD = gcc +OBJOUT = -o +LFLAGS = +OFLAG = -o +COUT = -c +# Flag: PORT_OBJS +# Port specific object files can be added here +PORT_OBJS = $(PORT_DIR)/core_portme$(OEXT) +PORT_CLEAN = *$(OEXT) + +$(OPATH)%$(OEXT) : %.c + $(CC) $(CFLAGS) $(XCFLAGS) $(COUT) $< $(OBJOUT) $@ + +endif + +# Target: port_prebuild +# Generate any files that are needed before actual build starts. +# E.g. generate profile guidance files. Sample PGO generation for gcc enabled with PGO=1 +# - First, check if PGO was defined on the command line, if so, need to add -fprofile-use to compile line. +# - Second, if PGO reference has not yet been generated, add a step to the prebuild that will build a profile-generate version and run it. +# Note - Using REBUILD=1 +# +# Use make PGO=1 to invoke this sample processing. + +ifdef PGO + ifeq (,$(findstring $(PGO),gen)) + PGO_STAGE=build_pgo_gcc + CFLAGS+=-fprofile-use + endif + PORT_CLEAN+=*.gcda *.gcno gmon.out +endif + +.PHONY: port_prebuild +port_prebuild: $(PGO_STAGE) + +.PHONY: build_pgo_gcc +build_pgo_gcc: + $(MAKE) PGO=gen XCFLAGS="$(XCFLAGS) -fprofile-generate -DTOTAL_DATA_SIZE=1200" ITERATIONS=10 gen_pgo_data REBUILD=1 + +# Target: port_postbuild +# Generate any files that are needed after actual build end. +# E.g. change format to srec, bin, zip in order to be able to load into flash +.PHONY: port_postbuild +port_postbuild: + +# Target: port_postrun +# Do platform specific after run stuff. +# E.g. reset the board, backup the logfiles etc. +.PHONY: port_postrun +port_postrun: + +# Target: port_prerun +# Do platform specific after run stuff. +# E.g. reset the board, backup the logfiles etc. +.PHONY: port_prerun +port_prerun: + +# Target: port_postload +# Do platform specific after load stuff. +# E.g. reset the reset power to the flash eraser +.PHONY: port_postload +port_postload: + +# Target: port_preload +# Do platform specific before load stuff. +# E.g. reset the reset power to the flash eraser +.PHONY: port_preload +port_preload: + + +# FLAG: OPATH +# Path to the output folder. Default - current folder. +OPATH = ./ +MKDIR = mkdir -p + +# FLAG: PERL +# Define perl executable to calculate the geomean if running separate. +PERL=perl diff --git a/docs/READM.md b/docs/READM.md new file mode 100644 index 0000000..6f71f42 --- /dev/null +++ b/docs/READM.md @@ -0,0 +1 @@ +This folder contains the original, unaltered documents from the CoreMark V1.0 release. diff --git a/docs/balance_O0_joined.png b/docs/balance_O0_joined.png new file mode 100644 index 0000000000000000000000000000000000000000..46b41583a8b834d371c2bced376f956e0f54065b GIT binary patch literal 48672 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%0AFA5E4ee=T>j2E2PMnSINnnp$d9= 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

erIh6C^&;I#|Jl%eOcwEV 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 literal 0 HcmV?d00001 diff --git a/docs/html/files/PIC32/core_portme-mak.html b/docs/html/files/PIC32/core_portme-mak.html new file mode 100644 index 0000000..c222bac --- /dev/null +++ b/docs/html/files/PIC32/core_portme-mak.html @@ -0,0 +1,68 @@ + + +core_portme.mak - CoreMark + + + + + + + +

core_portme.mak

Summary
core_portme.mak
Variables
OUTFLAGUse this flag to define how to to get an executable (e.g -o)
CFLAGSUse this flag to define compiler options.
LFLAGS_ENDDefine any libraries needed for linking or other flags that should come at the end of the link line (e.g.
SEPARATE_COMPILEDefine if you need to separate compilation from link stage.
PORT_OBJSPort specific object files can be added here
Build Targets
port_prebuildGenerate any files that are needed before actual build starts.
port_postbuildGenerate any files that are needed after actual build end.
port_postrunDo platform specific after run stuff.
port_prerunDo platform specific after run stuff.
port_postloadDo platform specific after load stuff.
port_preloadDo platform specific before load stuff.
Variables
OPATH
PERLDefine perl executable to calculate the geomean if running separate.
+ +

Variables

+ +

OUTFLAG

Use this flag to define how to to get an executable (e.g -o)

+ +

CFLAGS

Use this flag to define compiler options.  Note, you can add compiler options from the command line using XCFLAGS=”other flags”

+ +

LFLAGS_END

Define any libraries needed for linking or other flags that should come at the end of the link line (e.g. linker scripts).  Note: On certain platforms, the default clock_gettime implementation is supported but requires linking of librt.

+ +

SEPARATE_COMPILE

Define if you need to separate compilation from link stage.  In this case, you also need to define below how to create an object file, and how to link.

+ +

PORT_OBJS

Port specific object files can be added here

+ +

Build Targets

+ +

port_prebuild

Generate any files that are needed before actual build starts.  E.g. generate profile guidance files.  Sample PGO generation for gcc enabled with PGO=1

  • First, check if PGO was defined on the command line, if so, need to add -fprofile-use to compile line.
  • Second, if PGO reference has not yet been generated, add a step to the prebuild that will build a profile-generate version and run it.
NoteUsing REBUILD=1

Use make PGO=1 to invoke this sample processing.

+ +

port_postbuild

Generate any files that are needed after actual build end.  E.g. change format to srec, bin, zip in order to be able to load into flash

+ +

port_postrun

Do platform specific after run stuff.  E.g. reset the board, backup the logfiles etc.

+ +

port_prerun

Do platform specific after run stuff.  E.g. reset the board, backup the logfiles etc.

+ +

port_postload

Do platform specific after load stuff.  E.g. reset the reset power to the flash eraser

+ +

port_preload

Do platform specific before load stuff.  E.g. reset the reset power to the flash eraser

+ +

Variables

+ +

OPATH

Path to the output folder.  Defaultcurrent folder.
+ +

PERL

Define perl executable to calculate the geomean if running separate.

+ +
+ + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/docs/html/files/core_list_join-c.html b/docs/html/files/core_list_join-c.html new file mode 100644 index 0000000..6ee2aee --- /dev/null +++ b/docs/html/files/core_list_join-c.html @@ -0,0 +1,58 @@ + + +/cygdrive/d/dev/code/coremark/core_list_join.c - CoreMark + + + + + + + +

core_list_join.c

Summary
core_list_join.c
DescriptionBenchmark using a linked list.
Functions
cmp_complexCompare the data item in a list cell.
cmp_idxCompare the idx item in a list cell, and regen the data.
core_list_initInitialize list with data.
core_list_insertInsert an item to the list
core_list_removeRemove an item from the list.
core_list_undo_removeUndo a remove operation.
core_list_findFind an item in the list
core_list_reverseReverse a list
core_list_mergesortSort the list in place without recursion.
+ +

Description

Benchmark using a linked list.

Linked list is a common data structure used in many applications.

For our purposes, this will excercise the memory units of the processor.  In particular, usage of the list pointers to find and alter data.

We are not using Malloc since some platforms do not support this library.

Instead, the memory block being passed in is used to create a list, and the benchmark takes care not to add more items then can be accomodated by the memory block.  The porting layer will make sure that we have a valid memory block.

All operations are done in place, without using any extra memory.

The list itself contains list pointers and pointers to data items.  Data items contain the following:

idxAn index that captures the initial order of the list.
dataVariable data initialized based on the input parameters.  The 16b are divided as follows:
  • Upper 8b are backup of original data.
  • Bit 7 indicates if the lower 7 bits are to be used as is or calculated.
  • Bits 0-2 indicate type of operation to perform to get a 7b value.
  • Bits 3-6 provide input for the operation.
+ +

Functions

+ +

cmp_complex

ee_s32 cmp_complex(list_data *a,
list_data *b,
core_results *res)

Compare the data item in a list cell.

Can be used by mergesort.

+ +

cmp_idx

ee_s32 cmp_idx(list_data *a,
list_data *b,
core_results *res)

Compare the idx item in a list cell, and regen the data.

Can be used by mergesort.

+ +

core_list_init

list_head *core_list_init(ee_u32 blksize,
list_head *memblock,
ee_s16 seed)

Initialize list with data.

Parameters

blksizeSize of memory to be initialized.
memblockPointer to memory block.
seedActual values chosen depend on the seed parameter.  The seed parameter MUST be supplied from a source that cannot be determined at compile time

Returns

Pointer to the head of the list.

+ +

core_list_insert

list_head *core_list_insert_new(list_head *insert_point,
list_data *info,
list_head **memblock,
list_data **datablock ,
list_head *memblock_end,
list_data *datablock_end)

Insert an item to the list

Parameters

insert_pointwhere to insert the item.
infodata for the cell.
memblockpointer for the list header
datablockpointer for the list data
memblock_endend of region for list headers
datablock_endend of region for list data

Returns

Pointer to new item.

+ +

core_list_remove

list_head *core_list_remove(list_head *item)

Remove an item from the list.

Operation

For a singly linked list, remove by copying the data from the next item over to the current cell, and unlinking the next item.

Note

since there is always a fake item at the end of the list, no need to check for NULL.

Returns

Removed item.

+ +

core_list_undo_remove

list_head *core_list_undo_remove(list_head *item_removed,
list_head *item_modified)

Undo a remove operation.

Operation

Since we want each iteration of the benchmark to be exactly the same, we need to be able to undo a remove.  Link the removed item back into the list, and switch the info items.

Parameters

item_removedReturn value from the core_list_remove
item_modifiedList item that was modified during core_list_remove

Returns

The item that was linked back to the list.

+ +

core_list_find

list_head *core_list_find(list_head *list,
list_data *info)

Find an item in the list

Operation

Find an item by idx (if not 0) or specific data value

Parameters

listlist head
infoidx or data to find

Returns

Found item, or NULL if not found.

+ +

core_list_reverse

list_head *core_list_reverse(list_head *list)

Reverse a list

Operation

Rearrange the pointers so the list is reversed.

Parameters

listlist head
infoidx or data to find

Returns

Found item, or NULL if not found.

+ +

core_list_mergesort

list_head *core_list_mergesort(list_head *list,
list_cmp cmp,
core_results *res)

Sort the list in place without recursion.

Description

Use mergesort, as for linked list this is a realistic solution.  Also, since this is aimed at embedded, care was taken to use iterative rather then recursive algorithm.  The sort can either return the list to original order (by idx) , or use the data item to invoke other other algorithms and change the order of the list.

Parameters

listlist to be sorted.
cmpcmp function to use

Returns

New head of the list.

Note

We have a special header for the list that will always be first, but the algorithm could theoretically modify where the list starts.

+ +
+ + + + + + + + + + +
ee_s32 cmp_complex(list_data *a,
list_data *b,
core_results *res)
Compare the data item in a list cell.
ee_s32 cmp_idx(list_data *a,
list_data *b,
core_results *res)
Compare the idx item in a list cell, and regen the data.
list_head *core_list_init(ee_u32 blksize,
list_head *memblock,
ee_s16 seed)
Initialize list with data.
list_head *core_list_insert_new(list_head *insert_point,
list_data *info,
list_head **memblock,
list_data **datablock ,
list_head *memblock_end,
list_data *datablock_end)
Insert an item to the list
list_head *core_list_remove(list_head *item)
Remove an item from the list.
list_head *core_list_undo_remove(list_head *item_removed,
list_head *item_modified)
Undo a remove operation.
list_head *core_list_find(list_head *list,
list_data *info)
Find an item in the list
list_head *core_list_reverse(list_head *list)
Reverse a list
list_head *core_list_mergesort(list_head *list,
list_cmp cmp,
core_results *res)
Sort the list in place without recursion.
+ + + + + + + + \ No newline at end of file diff --git a/docs/html/files/core_main-c.html b/docs/html/files/core_main-c.html new file mode 100644 index 0000000..8477441 --- /dev/null +++ b/docs/html/files/core_main-c.html @@ -0,0 +1,42 @@ + + +core_main.c - CoreMark + + + + + + + +

core_main.c

This file contains the framework to acquire a block of memory, seed initial parameters, tun t he benchmark and report the results.

Summary
core_main.cThis file contains the framework to acquire a block of memory, seed initial parameters, tun t he benchmark and report the results.
Functions
iterateRun the benchmark for a specified number of iterations.
mainMain entry routine for the benchmark.
+ +

Functions

+ +

iterate

Run the benchmark for a specified number of iterations.

Operation

For each type of benchmarked algorithm: a - Initialize the data block for the algorithm. b - Execute the algorithm N times.

Returns

NULL.

+ +

main

#if MAIN_HAS_NOARGC MAIN_RETURN_TYPE main(void)

Main entry routine for the benchmark.  This function is responsible for the following steps:

1Initialize input seeds from a source that cannot be determined at compile time.
2Initialize memory block for use.
3Run and time the benchmark.
4Report results, testing the validity of the output if the seeds are known.

Arguments

1first seed : Any value
2second seed : Must be identical to first for iterations to be identical
3third seed : Any value, should be at least an order of magnitude less then the input size, but bigger then 32.
4Iterations : Special, if set to 0, iterations will be automatically determined such that the benchmark will run between 10 to 100 secs
+ +
+ + + + + + + + + + +
#if MAIN_HAS_NOARGC MAIN_RETURN_TYPE main(void)
Main entry routine for the benchmark.
+ + + + + + + + \ No newline at end of file diff --git a/docs/html/files/core_matrix-c.html b/docs/html/files/core_matrix-c.html new file mode 100644 index 0000000..2ad041b --- /dev/null +++ b/docs/html/files/core_matrix-c.html @@ -0,0 +1,56 @@ + + +/cygdrive/d/dev/code/coremark/core_matrix.c - CoreMark + + + + + + + +

core_matrix.c

Summary
core_matrix.c
DescriptionMatrix manipulation benchmark
Functions
core_bench_matrixBenchmark function
matrix_testPerform matrix manipulation.
matrix_sumCalculate a function that depends on the values of elements in the matrix.
matrix_mul_constMultiply a matrix by a constant.
matrix_add_constAdd a constant value to all elements of a matrix.
matrix_mul_vectMultiply a matrix by a vector.
matrix_mul_matrixMultiply a matrix by a matrix.
matrix_mul_matrix_bitextractMultiply a matrix by a matrix, and extract some bits from the result.
+ +

Description

Matrix manipulation benchmark

This very simple algorithm forms the basis of many more complex algorithms.

The tight inner loop is the focus of many optimizations (compiler as well as hardware based) and is thus relevant for embedded processing.

The total available data space will be divided to 3 parts

NxN Matrix Ainitialized with small values (upper 3/4 of the bits all zero).
NxN Matrix Binitialized with medium values (upper half of the bits all zero).
NxN Matrix Cused for the result.

The actual values for A and B must be derived based on input that is not available at compile time.

+ +

Functions

+ +

core_bench_matrix

ee_u16 core_bench_matrix(mat_params *p,
ee_s16 seed,
ee_u16 crc)

Benchmark function

Iterate matrix_test N times, changing the matrix values slightly by a constant amount each time.

+ +

matrix_test

ee_s16 matrix_test(ee_u32 N,
MATRES *C,
MATDAT *A,
MATDAT *B,
MATDAT val)

Perform matrix manipulation.

Parameters

NDimensions of the matrix.
Cmemory for result matrix.
Ainput matrix
Boperator matrix (not changed during operations)

Returns

A CRC value that captures all results calculated in the function.  In particular, crc of the value calculated on the result matrix after each step by matrix_sum.

Operation

1Add a constant value to all elements of a matrix.
2Multiply a matrix by a constant.
3Multiply a matrix by a vector.
4Multiply a matrix by a matrix.
5Add a constant value to all elements of a matrix.

After the last step, matrix A is back to original contents.

+ +

matrix_sum

ee_s16 matrix_sum(ee_u32 N,
MATRES *C,
MATDAT clipval)

Calculate a function that depends on the values of elements in the matrix.

For each element, accumulate into a temporary variable.

As long as this value is under the parameter clipval, add 1 to the result if the element is bigger then the previous.

Otherwise, reset the accumulator and add 10 to the result.

+ +

matrix_mul_const

void matrix_mul_const(ee_u32 N,
MATRES *C,
MATDAT *A,
MATDAT val)

Multiply a matrix by a constant.  This could be used as a scaler for instance.

+ +

matrix_add_const

void matrix_add_const(ee_u32 N,
MATDAT *A,
MATDAT val)

Add a constant value to all elements of a matrix.

+ +

matrix_mul_vect

void matrix_mul_vect(ee_u32 N,
MATRES *C,
MATDAT *A,
MATDAT *B)

Multiply a matrix by a vector.  This is common in many simple filters (e.g. fir where a vector of coefficients is applied to the matrix.)

+ +

matrix_mul_matrix

void matrix_mul_matrix(ee_u32 N,
MATRES *C,
MATDAT *A,
MATDAT *B)

Multiply a matrix by a matrix.  Basic code is used in many algorithms, mostly with minor changes such as scaling.

+ +

matrix_mul_matrix_bitextract

void matrix_mul_matrix_bitextract(ee_u32 N,
MATRES *C,
MATDAT *A,
MATDAT *B)

Multiply a matrix by a matrix, and extract some bits from the result.  Basic code is used in many algorithms, mostly with minor changes such as scaling.

+ +
+ + + + + + + + + + +
ee_u16 core_bench_matrix(mat_params *p,
ee_s16 seed,
ee_u16 crc)
Benchmark function
ee_s16 matrix_test(ee_u32 N,
MATRES *C,
MATDAT *A,
MATDAT *B,
MATDAT val)
Perform matrix manipulation.
ee_s16 matrix_sum(ee_u32 N,
MATRES *C,
MATDAT clipval)
Calculate a function that depends on the values of elements in the matrix.
void matrix_mul_const(ee_u32 N,
MATRES *C,
MATDAT *A,
MATDAT val)
Multiply a matrix by a constant.
void matrix_add_const(ee_u32 N,
MATDAT *A,
MATDAT val)
Add a constant value to all elements of a matrix.
void matrix_mul_vect(ee_u32 N,
MATRES *C,
MATDAT *A,
MATDAT *B)
Multiply a matrix by a vector.
void matrix_mul_matrix(ee_u32 N,
MATRES *C,
MATDAT *A,
MATDAT *B)
Multiply a matrix by a matrix.
void matrix_mul_matrix_bitextract(ee_u32 N,
MATRES *C,
MATDAT *A,
MATDAT *B)
Multiply a matrix by a matrix, and extract some bits from the result.
+ + + + + + + + \ No newline at end of file diff --git a/docs/html/files/core_state-c.html b/docs/html/files/core_state-c.html new file mode 100644 index 0000000..9f80359 --- /dev/null +++ b/docs/html/files/core_state-c.html @@ -0,0 +1,46 @@ + + +/cygdrive/d/dev/code/coremark/core_state.c - CoreMark + + + + + + + +

core_state.c

Summary
core_state.c
DescriptionSimple state machines like this one are used in many embedded products.
Functions
core_bench_stateBenchmark function
core_init_stateInitialize the input data for the state machine.
core_state_transitionActual state machine.
+ +

Description

Simple state machines like this one are used in many embedded products.

For more complex state machines, sometimes a state transition table implementation is used instead, trading speed of direct coding for ease of maintenance.

Since the main goal of using a state machine in CoreMark is to excercise the switch/if behaviour, we are using a small moore machine.

In particular, this machine tests type of string input, trying to determine whether the input is a number or something else.  (see core_state).

core_state
+ +

Functions

+ +

core_bench_state

ee_u16 core_bench_state(ee_u32 blksize,
ee_u8 *memblock,
ee_s16 seed1,
ee_s16 seed2,
ee_s16 step,
ee_u16 crc)

Benchmark function

Go over the input twice, once direct, and once after introducing some corruption.

+ +

core_init_state

void core_init_state(ee_u32 size,
ee_s16 seed,
ee_u8 *p)

Initialize the input data for the state machine.

Populate the input with several predetermined strings, interspersed.  Actual patterns chosen depend on the seed parameter.

Note

The seed parameter MUST be supplied from a source that cannot be determined at compile time

+ +

core_state_transition

enum CORE_STATE core_state_transition(ee_u8 **instr ,
ee_u32 *transition_count)

Actual state machine.

The state machine will continue scanning until either

1an invalid input is detcted.
2a valid number has been detected.

The input pointer is updated to point to the end of the token, and the end state is returned (either specific format determined or invalid).

+ +
+ + + + + + + + + + +
ee_u16 core_bench_state(ee_u32 blksize,
ee_u8 *memblock,
ee_s16 seed1,
ee_s16 seed2,
ee_s16 step,
ee_u16 crc)
Benchmark function
void core_init_state(ee_u32 size,
ee_s16 seed,
ee_u8 *p)
Initialize the input data for the state machine.
enum CORE_STATE core_state_transition(ee_u8 **instr ,
ee_u32 *transition_count)
Actual state machine.
+ + + + + + + + \ No newline at end of file diff --git a/docs/html/files/core_util-c.html b/docs/html/files/core_util-c.html new file mode 100644 index 0000000..3ebdb38 --- /dev/null +++ b/docs/html/files/core_util-c.html @@ -0,0 +1,42 @@ + + +/cygdrive/d/dev/code/coremark/core_util.c - CoreMark + + + + + + + +

core_util.c

Summary
core_util.c
Functions
get_seedGet a values that cannot be determined at compile time.
crc*Service functions to calculate 16b CRC code.
+ +

Functions

+ +

get_seed

Get a values that cannot be determined at compile time.

Since different embedded systems and compilers are used, 3 different methods are provided

1Using a volatile variable.  This method is only valid if the compiler is forced to generate code that reads the value of a volatile variable from memory at run time.  Please note, if using this method, you would need to modify core_portme.c to generate training profile.
2Command line arguments.  This is the preferred method if command line arguments are supported.
3System function.  If none of the first 2 methods is available on the platform, a system function which is not a stub can be used.

e.g. read the value on GPIO pins connected to switches, or invoke special simulator functions.

+ +

crc*

Service functions to calculate 16b CRC code.

+ +
+ + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/docs/html/files/coremark-h.html b/docs/html/files/coremark-h.html new file mode 100644 index 0000000..337bc1a --- /dev/null +++ b/docs/html/files/coremark-h.html @@ -0,0 +1,46 @@ + + +/cygdrive/d/dev/code/coremark/coremark.h - CoreMark + + + + + + + +

coremark.h

Summary
coremark.h
DescriptionThis file contains declarations of the various benchmark functions.
Configuration
TOTAL_DATA_SIZEDefine total size for data algorithms will operate on
Types
secs_retFor machines that have floating point support, get number of seconds as a double.
+ +

Description

This file contains declarations of the various benchmark functions.

+ +

Configuration

+ +

TOTAL_DATA_SIZE

Define total size for data algorithms will operate on

+ +

Types

+ +

secs_ret

For machines that have floating point support, get number of seconds as a double.  Otherwise an unsigned int.

+ +
+ + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/docs/html/files/docs/core_state.png b/docs/html/files/docs/core_state.png new file mode 100644 index 0000000000000000000000000000000000000000..9b5a4ea6078f44f7ffab2d06574052d01ae0db55 GIT binary patch literal 72093 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

-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 + +core_portme.c - CoreMark + + + + + + + +

core_portme.c

Summary
core_portme.c
portable_mallocProvide malloc() functionality in a platform specific way.
portable_freeProvide free() functionality in a platform specific way.
TIMER_RES_DIVIDERDivider to trade off timer resolution and total time that can be measured.
start_timeThis function will be called right before starting the timed portion of the benchmark.
stop_timeThis function will be called right after ending the timed portion of the benchmark.
get_timeReturn an abstract “ticks” number that signifies time on the system.
time_in_secsConvert the value returned by get_time to seconds.
portable_initTarget specific initialization code Test for some common mistakes.
portable_finiTarget specific final code
core_start_parallelStart benchmarking in a parallel context.
core_stop_parallelStop a parallel context execution of coremark, and gather the results.
+ +

portable_malloc

void *portable_malloc(size_t size)

Provide malloc() functionality in a platform specific way.

+ +

portable_free

void portable_free(void *p)

Provide free() functionality in a platform specific way.

+ +

TIMER_RES_DIVIDER

Divider to trade off timer resolution and total time that can be measured.

Use lower values to increase resolution, but make sure that overflow does not occur.  If there are issues with the return value overflowing, increase this value.

+ +

start_time

void start_time(void)

This function will be called right before starting the timed portion of the benchmark.

Implementation may be capturing a system timer (as implemented in the example code) or zeroing some system parameters - e.g. setting the cpu clocks cycles to 0.

+ +

stop_time

void stop_time(void)

This function will be called right after ending the timed portion of the benchmark.

Implementation may be capturing a system timer (as implemented in the example code) or other system parameters - e.g. reading the current value of cpu cycles counter.

+ +

get_time

CORE_TICKS get_time(void)

Return an abstract “ticks” number that signifies time on the system.

Actual value returned may be cpu cycles, milliseconds or any other value, as long as it can be converted to seconds by time_in_secs.  This methodology is taken to accomodate any hardware or simulated platform.  The sample implementation returns millisecs by default, and the resolution is controlled by TIMER_RES_DIVIDER

+ +

time_in_secs

secs_ret time_in_secs(CORE_TICKS ticks)

Convert the value returned by get_time to seconds.

The secs_ret type is used to accomodate systems with no support for floating point.  Default implementation implemented by the EE_TICKS_PER_SEC macro above.

+ +

portable_init

void portable_init(core_portable *p,
int *argc,
char *argv[])

Target specific initialization code Test for some common mistakes.

+ +

portable_fini

void portable_fini(core_portable *p)

Target specific final code

+ +

core_start_parallel

Start benchmarking in a parallel context.

Three implementations are provided, one using pthreads, one using fork and shared mem, and one using fork and sockets.  Other implementations using MCAPI or other standards can easily be devised.

+ +

core_stop_parallel

Stop a parallel context execution of coremark, and gather the results.

Three implementations are provided, one using pthreads, one using fork and shared mem, and one using fork and sockets.  Other implementations using MCAPI or other standards can easily be devised.

+ +
+ + + + + + + + + + +
void *portable_malloc(size_t size)
Provide malloc() functionality in a platform specific way.
void portable_free(void *p)
Provide free() functionality in a platform specific way.
void start_time(void)
This function will be called right before starting the timed portion of the benchmark.
void stop_time(void)
This function will be called right after ending the timed portion of the benchmark.
CORE_TICKS get_time(void)
Return an abstract “ticks” number that signifies time on the system.
secs_ret time_in_secs(CORE_TICKS ticks)
Convert the value returned by get_time to seconds.
void portable_init(core_portable *p,
int *argc,
char *argv[])
Target specific initialization code Test for some common mistakes.
void portable_fini(core_portable *p)
Target specific final code
Divider to trade off timer resolution and total time that can be measured.
For machines that have floating point support, get number of seconds as a double.
+ + + + + + + + \ No newline at end of file diff --git a/docs/html/files/linux/core_portme-h.html b/docs/html/files/linux/core_portme-h.html new file mode 100644 index 0000000..90810f1 --- /dev/null +++ b/docs/html/files/linux/core_portme-h.html @@ -0,0 +1,72 @@ + + +core_portme.h - CoreMark + + + + + + + +

core_portme.h

Summary
core_portme.h
DescriptionThis file contains configuration constants required to execute on different platforms
Configuration
HAS_FLOATDefine to 1 if the platform supports floating point.
HAS_TIME_HDefine to 1 if platform has the time.h header file, and implementation of functions thereof.
USE_CLOCKDefine to 1 if platform has the time.h header file, and implementation of functions thereof.
HAS_STDIODefine to 1 if the platform has stdio.h.
HAS_PRINTFDefine to 1 if the platform has stdio.h and implements the printf function.
CORE_TICKSDefine type of return from the timing functions.
SEED_METHODDefines method to get seed values that cannot be computed at compile time.
MEM_METHODDefines method to get a block of memry.
MULTITHREADDefine for parallel execution
USE_PTHREADSample implementation for launching parallel contexts This implementation uses pthread_thread_create and pthread_join.
USE_FORKSample implementation for launching parallel contexts This implementation uses fork, waitpid, shmget,shmat and shmdt.
USE_SOCKETSample implementation for launching parallel contexts This implementation uses fork, socket, sendto and recvfrom
MAIN_HAS_NOARGCNeeded if platform does not support getting arguments to main.
MAIN_HAS_NORETURNNeeded if platform does not support returning a value from main.
Variables
default_num_contextsNumber of contexts to spawn in multicore context.
+ +

Description

This file contains configuration constants required to execute on different platforms

+ +

Configuration

+ +

HAS_FLOAT

Define to 1 if the platform supports floating point.

+ +

HAS_TIME_H

Define to 1 if platform has the time.h header file, and implementation of functions thereof.

+ +

USE_CLOCK

Define to 1 if platform has the time.h header file, and implementation of functions thereof.

+ +

HAS_STDIO

Define to 1 if the platform has stdio.h.

+ +

HAS_PRINTF

Define to 1 if the platform has stdio.h and implements the printf function.

+ +

CORE_TICKS

Define type of return from the timing functions.

+ +

SEED_METHOD

Defines method to get seed values that cannot be computed at compile time.

Valid values

SEED_ARGfrom command line.
SEED_FUNCfrom a system function.
SEED_VOLATILEfrom volatile variables.
+ +

MEM_METHOD

Defines method to get a block of memry.

Valid values

MEM_MALLOCfor platforms that implement malloc and have malloc.h.
MEM_STATICto use a static memory array.
MEM_STACKto allocate the data block on the stack (NYI).
+ +

MULTITHREAD

Define for parallel execution

Valid values

1only one context (default).
N>1will execute N copies in parallel.

Note

If this flag is defined to more then 1, an implementation for launching parallel contexts must be defined.

Two sample implementations are provided.  Use USE_PTHREAD or USE_FORK to enable them.

It is valid to have a different implementation of core_start_parallel and <core_end_parallel> in core_portme.c, to fit a particular architecture.

+ +

USE_PTHREAD

Sample implementation for launching parallel contexts This implementation uses pthread_thread_create and pthread_join.

Valid values

0Do not use pthreads API.
1Use pthreads API

Note

This flag only matters if MULTITHREAD has been defined to a value greater then 1.

+ +

USE_FORK

Sample implementation for launching parallel contexts This implementation uses fork, waitpid, shmget,shmat and shmdt.

Valid values

0Do not use fork API.
1Use fork API

Note

This flag only matters if MULTITHREAD has been defined to a value greater then 1.

+ +

USE_SOCKET

Sample implementation for launching parallel contexts This implementation uses fork, socket, sendto and recvfrom

Valid values

0Do not use fork and sockets API.
1Use fork and sockets API

Note

This flag only matters if MULTITHREAD has been defined to a value greater then 1.

+ +

MAIN_HAS_NOARGC

Needed if platform does not support getting arguments to main.

Valid values

0argc/argv to main is supported
1argc/argv to main is not supported
+ +

MAIN_HAS_NORETURN

Needed if platform does not support returning a value from main.

Valid values

0main returns an int, and return value will be 0.
1platform does not support returning a value from main
+ +

Variables

+ +

default_num_contexts

extern ee_u32 default_num_contexts

Number of contexts to spawn in multicore context.  Override this global value to change number of contexts used.

Note

This value may not be set higher then the MULTITHREAD define.

To experiment, you can set the MULTITHREAD define to the highest value expected, and use argc/argv in the portable_init to set this value from the command line.

+ +
+ + + + + + + + + + +
extern ee_u32 default_num_contexts
Number of contexts to spawn in multicore context.
Sample implementation for launching parallel contexts This implementation uses pthread_thread_create and pthread_join.
Sample implementation for launching parallel contexts This implementation uses fork, waitpid, shmget,shmat and shmdt.
Start benchmarking in a parallel context.
Define for parallel execution
void portable_init(core_portable *p,
int *argc,
char *argv[])
Target specific initialization code Test for some common mistakes.
+ + + + + + + + \ No newline at end of file diff --git a/docs/html/files/linux/core_portme-mak.html b/docs/html/files/linux/core_portme-mak.html new file mode 100644 index 0000000..ffd6cbe --- /dev/null +++ b/docs/html/files/linux/core_portme-mak.html @@ -0,0 +1,76 @@ + + +core_portme.mak - CoreMark + + + + + + + +

core_portme.mak

Summary
core_portme.mak
Variables
OUTFLAGUse this flag to define how to to get an executable (e.g -o)
CCUse this flag to define compiler to use
CFLAGSUse this flag to define compiler options.
LFLAGS_ENDDefine any libraries needed for linking or other flags that should come at the end of the link line (e.g.
PORT_SRCSPort specific source files can be added here
LOADDefine this flag if you need to load to a target, as in a cross compile environment.
RUNDefine this flag if running does not consist of simple invocation of the binary.
SEPARATE_COMPILEDefine if you need to separate compilation from link stage.
PORT_OBJSPort specific object files can be added here
Build Targets
port_prebuildGenerate any files that are needed before actual build starts.
port_postbuildGenerate any files that are needed after actual build end.
port_postrunDo platform specific after run stuff.
port_prerunDo platform specific after run stuff.
port_postloadDo platform specific after load stuff.
port_preloadDo platform specific before load stuff.
Variables
OPATH
PERLDefine perl executable to calculate the geomean if running separate.
+ +

Variables

+ +

OUTFLAG

Use this flag to define how to to get an executable (e.g -o)

+ +

CC

Use this flag to define compiler to use

+ +

CFLAGS

Use this flag to define compiler options.  Note, you can add compiler options from the command line using XCFLAGS=”other flags”

+ +

LFLAGS_END

Define any libraries needed for linking or other flags that should come at the end of the link line (e.g. linker scripts).  Note: On certain platforms, the default clock_gettime implementation is supported but requires linking of librt.

+ +

PORT_SRCS

Port specific source files can be added here

+ +

LOAD

Define this flag if you need to load to a target, as in a cross compile environment.

+ +

RUN

Define this flag if running does not consist of simple invocation of the binary.  In a cross compile environment, you need to define this.

+ +

SEPARATE_COMPILE

Define if you need to separate compilation from link stage.  In this case, you also need to define below how to create an object file, and how to link.

+ +

PORT_OBJS

Port specific object files can be added here

+ +

Build Targets

+ +

port_prebuild

Generate any files that are needed before actual build starts.  E.g. generate profile guidance files.  Sample PGO generation for gcc enabled with PGO=1

  • First, check if PGO was defined on the command line, if so, need to add -fprofile-use to compile line.
  • Second, if PGO reference has not yet been generated, add a step to the prebuild that will build a profile-generate version and run it.
NoteUsing REBUILD=1

Use make PGO=1 to invoke this sample processing.

+ +

port_postbuild

Generate any files that are needed after actual build end.  E.g. change format to srec, bin, zip in order to be able to load into flash

+ +

port_postrun

Do platform specific after run stuff.  E.g. reset the board, backup the logfiles etc.

+ +

port_prerun

Do platform specific after run stuff.  E.g. reset the board, backup the logfiles etc.

+ +

port_postload

Do platform specific after load stuff.  E.g. reset the reset power to the flash eraser

+ +

port_preload

Do platform specific before load stuff.  E.g. reset the reset power to the flash eraser

+ +

Variables

+ +

OPATH

Path to the output folder.  Defaultcurrent folder.
+ +

PERL

Define perl executable to calculate the geomean if running separate.

+ +
+ + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/docs/html/files/readme-txt.html b/docs/html/files/readme-txt.html new file mode 100644 index 0000000..1ed6c66 --- /dev/null +++ b/docs/html/files/readme-txt.html @@ -0,0 +1,71 @@ + + +CoreMark + + + + + + + +

CoreMark

Summary
CoreMark
WelcomeCopyright 2009 EEMBC All rights reserved.
Building and runningDownload the release files from the www.coremark.org.
DocumentationWhen you unpack the documentation (tar -vzxf coremark_<version>_docs.tgz) a docs folder will be created.
Submitting resultsCoreMark results can be submitted on the web.
Run rulesWhat is and is not allowed.
Reporting rulesHow to report results on a data sheet?
Log File FormatThe log files have the following format
LegalSee LICENSE.txt or the word document file under docs/LICENSE.doc.
CreditsMany thanks to all of the individuals who helped with the development or testing of CoreMark including (Sorted by company name)
+ +

Welcome

Copyright 2009 EEMBC All rights reserved.  CoreMark is a trademark of EEMBC and EEMBC is a registered trademark of the Embedded Microprocessor Benchmark Consortium.

CoreMarks primary goals are simplicity and providing a method for testing only a processors core features.

For more information about EEMBC’s comprehensive embedded benchmark suites, please see www.eembc.org.

+ +

Building and running

Download the release files from the www.coremark.org.  You can verify the download using the coremark_<version>.md5 file

md5sum -c coremark_<version>.md5

Unpack the distribution (tar -vzxf coremark_<version>.tgz && tar -vzxf coremark_<version>_docs.tgz) then change to the coremark_<version> folder.

To build and run the benchmark, type

make

Full results are available in the files run1.log and run2.log.  CoreMark result can be found in run1.log.

For self hosted Linux or Cygwin platforms, a simple make should work.

Cross Compile

For cross compile platforms please adjust core_portme.mak, core_portme.h (and possibly core_portme.c) according to the specific platform used.  When porting to a new platform, it is recommended to copy one of the default port folders (e.g. mkdir <platform> && cp linux/* <platform>), adjust the porting files, and run

make PORT_DIR=<platform>

Systems without make

The following files need to be compiled:

For example

gcc -O2 -o coremark.exe core_list_join.c core_main.c core_matrix.c core_state.c core_util.c simple/core_portme.c -DPERFORMANCE_RUN=1 -DITERATIONS=1000
+./coremark.exe > run1.log

The above will compile the benchmark for a performance run and 1000 iterations.  Output is redirected to run1.log.

Make targets

runDefault target, creates run1.log and run2.log.
run1.logRun the benchmark with performance parameters, and output to run1.log
run2.logRun the benchmark with validation parameters, and output to run2.log
run3.logRun the benchmark with profile generation parameters, and output to run3.log
compilecompile the benchmark executable
linklink the benchmark executable
checktest MD5 of sources that may not be modified
cleanclean temporary files

ITERATIONS

By default, the benchmark will run between 10-100 seconds.  To override, use ITERATIONS=N

make ITERATIONS=10

Will run the benchmark for 10 iterations.  It is recommended to set a specific number of iterations in certain situations e.g.:

  • Running with a simulator
  • Measuring power/energy
  • Timing cannot be restarted

Minimum required run time

Results are only valid for reporting if the benchmark ran for at least 10 secs!

XCFLAGS

To add compiler flags from the command line, use XCFLAGS e.g.

make XCFLAGS="-g -DMULTITHREAD=4 -DUSE_FORK=1"
  • CORE_DEBUG

Define to compile for a debug run if you get incorrect CRC.

make XCFLAGS="-DCORE_DEBUG=1"
  • Parallel Execution

Use XCFLAGS=-DMULTITHREAD=N where N is number of threads to run in parallel.  Several implementations are available to execute in multiple contexts, or you can implement your own in core_portme.c.

make XCFLAGS="-DMULTITHREAD=4 -DUSE_PTHREAD"

Above will compile the benchmark for execution on 4 cores, using POSIX Threads API.

REBUILD

To force rebuild, add the flag REBUILD to the command line

make REBUILD=1

Check core_portme.mak for more important options.

Run parameters for the benchmark executable

Coremark executable takes several parameters as follows (if main accepts arguments).  1st - A seed value used for initialization of data.  2nd - A seed value used for initialization of data.  3rd - A seed value used for initialization of data.  4th - Number of iterations (0 for auto : default value) 5th - Reserved for internal use.  6th - Reserved for internal use.  7th - For malloc users only, ovreride the size of the input data buffer.

The run target from make will run coremark with 2 different data initialization seeds.

Alternative parameters

If not using malloc or command line arguments are not supported, the buffer size for the algorithms must be defined via the compiler define TOTAL_DATA_SIZE.  TOTAL_DATA_SIZE must be set to 2000 bytes (default) for standard runs.  The default for such a target when testing different configurations could be ...

make XCFLAGS="-DTOTAL_DATA_SIZE=6000 -DMAIN_HAS_NOARGC=1"
+ +

Documentation

When you unpack the documentation (tar -vzxf coremark_<version>_docs.tgz) a docs folder will be created.  Check the file docs/html/index.html and the website http://www.coremark.org for more info.

+ +

Submitting results

CoreMark results can be submitted on the web.

Open a web browser and go to http://www.coremark.org- /benchmark- /index.php?pg=benchmark Select the link to add a new score and follow the instructions.

+ +

Run rules

What is and is not allowed.

Required

1The benchmark needs to run for at least 10 seconds.
2All validation must succeed for seeds 0,0,0x66 and 0x3415,0x3415,0x66, buffer size of 2000 bytes total.
  • If not using command line arguments to main:
make XCFLAGS="-DPERFORMANCE_RUN=1" REBUILD=1 run1.log
+make XCFLAGS="-DVALIDATION_RUN=1" REBUILD=1 run2.log
3If using profile guided optimization, profile must be generated using seeds of 8,8,8, and buffer size of 1200 bytes total.
make XCFLAGS="-DTOTAL_DATA_SIZE=1200 -DPROFILE_RUN=1" REBUILD=1 run3.log
4All source files must be compiled with the same flags.
5All data type sizes must match size in bits such that:
  • ee_u8 is an 8 bits datatype.
  • ee_s16 is an 16 bits datatype.
  • ee_u16 is an 16 bits datatype.
  • ee_s32 is an 32 bits datatype.
  • ee_u32 is an 32 bits datatype.

Allowed

  • Changing number of iterations
  • Changing toolchain and build/load/run options
  • Changing method of acquiring a data memory block
  • Changing the method of acquiring seed values
  • Changing implementation in core_portme.c
  • Changing configuration values in core_portme.h
  • Changing core_portme.mak

Not allowed

  • Changing of source file other then core_portme* (use make check to validate)
+ +

Reporting rules

How to report results on a data sheet?

CoreMark 1.0 : N / C [/ P] [/ M]

NNumber of iterations per second with seeds 0,0,0x66,size=2000)
CCompiler version and flags
PParameters such as data and code allocation specifics
  • This parameter may be omitted if all data was allocated on the heap in RAM.
  • This parameter may not be omitted when reporting CoreMark/MHz
MType of parallel execution (if used) and number of contexts This parameter may be omitted if parallel execution was not used.

e.g.

CoreMark 1.0 : 128 / GCC 4.1.2 -O2 -fprofile-use / Heap in TCRAM / FORK:2

or

CoreMark 1.0 : 1400 / GCC 3.4 -O4

If reporting scaling results, the results must be reported as follows

CoreMark/MHz 1.0 : N / C / P [/ M]

PWhen reporting scaling results, memory parameter must also indicate memory frequency:core frequency ratio.
  • If the core has cache and cache frequency to core frequency ratio is configurable, that must also be included.

e.g.

CoreMark/MHz 1.0 : 1.47 / GCC 4.1.2 -O2 / DDR3(Heap) 30:1 Memory 1:1 Cache
+ +

Log File Format

The log files have the following format

2K performance run parameters for coremark. (Run type)
+CoreMark Size       : 666                   (Buffer size)
+Total ticks         : 25875                 (platform dependent value)
+Total time (secs)   : 25.875000             (actual time in seconds)
+Iterations/Sec      : 3864.734300           (Performance value to report)
+Iterations          : 100000                (number of iterations used)
+Compiler version    : GCC3.4.4              (Compiler and version)
+Compiler flags      : -O2                   (Compiler and linker flags)
+Memory location     : Code in flash, data in on chip RAM
+seedcrc             : 0xe9f5                (identifier for the input seeds)
+[0]crclist          : 0xe714                (validation for list part)
+[0]crcmatrix        : 0x1fd7                (validation for matrix part)
+[0]crcstate         : 0x8e3a                (validation for state part)
+[0]crcfinal         : 0x33ff                (iteration dependent output)
+Correct operation validated. See readme.txt for run and reporting rules.  (*Only when run is successful*)
+CoreMark 1.0 : 6508.490622 / GCC3.4.4 -O2 / Heap                          (*Only on a successful performance run*)
+ +

Legal

See LICENSE.txt or the word document file under docs/LICENSE.doc.  For more information on your legal rights to use this benchmark, please see http://www.coremark.org- /download- /register.php?pg=register

+ +

Credits

Many thanks to all of the individuals who helped with the development or testing of CoreMark including (Sorted by company name)

  • Alan Anderson, ADI
  • Adhikary Rajiv, ADI
  • Elena Stohr, ARM
  • Ian Rickards, ARM
  • Andrew Pickard, ARM
  • Trent Parker, CAVIUM
  • Shay Gal-On, EEMBC
  • Markus Levy, EEMBC
  • Ron Olson, IBM
  • Eyal Barzilay, MIPS
  • Jens Eltze, NEC
  • Hirohiko Ono, NEC
  • Ulrich Drees, NEC
  • Frank Roscheda, NEC
  • Rob Cosaro, NXP
  • Shumpei Kawasaki, RENESAS
+ +
+ + + + + + + + + + +
This file contains the framework to acquire a block of memory, seed initial parameters, tun t he benchmark and report the results.
+ + + + + + + + \ No newline at end of file diff --git a/docs/html/files/release_notes-txt.html b/docs/html/files/release_notes-txt.html new file mode 100644 index 0000000..6658c71 --- /dev/null +++ b/docs/html/files/release_notes-txt.html @@ -0,0 +1,56 @@ + + +Release Notes - CoreMark + + + + + + + +

Release Notes

Version: 1.01

History

Version 1.01

  • Added validation testing the sizes of datatypes.

Version 1.00

  • First public version.

Validation

This release was tested on the following platforms

  • x86 cygwin and gcc 3.4 (Quad, dual and single core systems)
  • x86 linux (Ubuntu/Fedora) and gcc (4.2/4.1) (Quad and single core systems)
  • MIPS64 BE linux and gcc 3.4 16 cores system
  • MIPS32 BE linux with CodeSourcery compiler 4.2-177 on Malta/Linux with a 1004K 3-core system
  • PPC simulator with gcc 4.2.2 (No OS)
  • PPC 64b BE linux (yellowdog) with gcc 3.4 and 4.1 (Dual core system)
  • BF533 with VDSP50
  • Renesas R8C/H8 MCU with HEW 4.05
  • NXP LPC1700 armcc v4.0.0.524
  • NEC 78K with IAR v4.61
  • ARM simulator with armcc v4

Coverage

GCOV results can be found on SVN under cover.

Memory analysis

Valgrind 3.4.0 used and no errors reported.

Balance analysis

Number of instructions executed for each function tested with cachegrind and found balanced with gcc and -O0.

Statistics

Lines

Lines  Blank  Cmnts  Source     AESL
+=====  =====  =====  =====  ==========  =======================================
+  469     66    170    251       627.5  core_list_join.c  (C)
+  330     18     54    268       670.0  core_main.c  (C)
+  256     32     80    146       365.0  core_matrix.c  (C)
+  240     16     51    186       465.0  core_state.c  (C)
+  165     11     20    134       335.0  core_util.c  (C)
+  150     23     36     98       245.0  coremark.h  (C)
+ 1610    166    411   1083      2707.5  ----- Benchmark -----  (6 files)
+  293     15     74    212       530.0  linux/core_portme.c  (C)
+  235     30    104    104       260.0  linux/core_portme.h  (C)
+  528     45    178    316       790.0  ----- Porting -----  (2 files)
+
+
+* For comparison, here are the stats for Dhrystone
+Lines  Blank  Cmnts  Source     AESL
+=====  =====  =====  =====  ==========  =======================================
+  311     15    242     54       135.0  dhry.h  (C)
+  789    132    119    553      1382.5  dhry_1.c  (C)
+  186     26     68    107       267.5  dhry_2.c  (C)
+ 1286    173    429    714      1785.0  ----- C -----  (3 files)
+ +
+ + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/docs/html/index.html b/docs/html/index.html new file mode 100644 index 0000000..f7a8868 --- /dev/null +++ b/docs/html/index.html @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/docs/html/index/BuildTargets.html b/docs/html/index/BuildTargets.html new file mode 100644 index 0000000..635c0ff --- /dev/null +++ b/docs/html/index/BuildTargets.html @@ -0,0 +1,31 @@ + + +Build Target Index - CoreMark + + + + + + + +
Build Target Index
$#! · 0-9 · A · B · C · D · E · F · G · H · I · J · K · L · M · N · O · P · Q · R · S · T · U · V · W · X · Y · Z
P
 port_postbuild
linux/ core_portme.makPIC32/ core_portme.mak
 port_postload
linux/ core_portme.makPIC32/ core_portme.mak
 port_postrun
linux/ core_portme.makPIC32/ core_portme.mak
 port_prebuild
linux/ core_portme.makPIC32/ core_portme.mak
 port_preload
linux/ core_portme.makPIC32/ core_portme.mak
 port_prerun
linux/ core_portme.makPIC32/ core_portme.mak
+ +
Generate any files that are needed after actual build end.
Do platform specific after load stuff.
Do platform specific after run stuff.
Generate any files that are needed before actual build starts.
Do platform specific before load stuff.
Do platform specific after run stuff.
+ +
+ + + + + + + + + + + + \ No newline at end of file diff --git a/docs/html/index/Configuration.html b/docs/html/index/Configuration.html new file mode 100644 index 0000000..8e5ef3a --- /dev/null +++ b/docs/html/index/Configuration.html @@ -0,0 +1,51 @@ + + +Configuration Index - CoreMark + + + + + + + +
Configuration Index
$#! · 0-9 · A · B · C · D · E · F · G · H · I · J · K · L · M · N · O · P · Q · R · S · T · U · V · W · X · Y · Z
C
 CORE_TICKS
H
 HAS_FLOAT
 HAS_PRINTF
 HAS_STDIO
 HAS_TIME_H
M
 MAIN_HAS_NOARGC
 MAIN_HAS_NORETURN
 MEM_METHOD
 MULTITHREAD
S
 SEED_METHOD
T
 TOTAL_DATA_SIZE
U
 USE_CLOCK
 USE_FORK
 USE_PTHREAD
 USE_SOCKET
+ +
Define type of return from the timing functions.
+ + + +
Define to 1 if the platform supports floating point.
Define to 1 if the platform has stdio.h and implements the printf function.
Define to 1 if the platform has stdio.h.
Define to 1 if platform has the time.h header file, and implementation of functions thereof.
+ + + +
Needed if platform does not support getting arguments to main.
Needed if platform does not support returning a value from main.
Defines method to get a block of memry.
Define for parallel execution
+ + + +
Defines method to get seed values that cannot be computed at compile time.
+ + + +
Define total size for data algorithms will operate on
+ + + +
Define to 1 if platform has the time.h header file, and implementation of functions thereof.
Sample implementation for launching parallel contexts This implementation uses fork, waitpid, shmget,shmat and shmdt.
Sample implementation for launching parallel contexts This implementation uses pthread_thread_create and pthread_join.
Sample implementation for launching parallel contexts This implementation uses fork, socket, sendto and recvfrom
+ +
+ + + + + + + + + + + + \ No newline at end of file diff --git a/docs/html/index/Configurations.html b/docs/html/index/Configurations.html new file mode 100644 index 0000000..0faee64 --- /dev/null +++ b/docs/html/index/Configurations.html @@ -0,0 +1,45 @@ + + +Configuration Index + + + + + + + + + +
Configuration Index
$#! · 0-9 · A · B · C · D · E · F · G · H · I · J · K · L · M · N · O · P · Q · R · S · T · U · V · W · X · Y · Z
H
 HAS_FLOAT
 HAS_STDIO
 HAS_TIME_H
M
 MEM_METHOD
S
 SEED_METHOD
T
 TOTAL_DATA_SIZE
+ +
Define to 1 if the platform supports floating point.
Define to 1 if the platform has stdio.h and implements the printf function.
Define to 1 if platform has the time.h header file, and implementation of functions thereof.
+ + + +
Defines method to get a block of memry.
+ + + +
Defines method to get seed values that cannot be computed at compile time.
+ + + +
Define total size for data algorithms will operate on
+ +
+ + + + + + + + + + + + \ No newline at end of file diff --git a/docs/html/index/Files.html b/docs/html/index/Files.html new file mode 100644 index 0000000..7e6d2fa --- /dev/null +++ b/docs/html/index/Files.html @@ -0,0 +1,35 @@ + + +File Index - CoreMark + + + + + + + +
File Index
$#! · 0-9 · A · B · C · D · E · F · G · H · I · J · K · L · M · N · O · P · Q · R · S · T · U · V · W · X · Y · Z
C
 core_list_join.c
 core_main.c
 core_matrix.c
 core_portme.c
 core_portme.h
 core_portme.mak
linux/ core_portme.makPIC32/ core_portme.mak
 core_state.c
 core_util.c
 CoreMark
 coremark.h
R
 Release Notes
+ +
This file contains the framework to acquire a block of memory, seed initial parameters, tun t he benchmark and report the results.
+ + + +
Version: 1.01
+ +
+ + + + + + + + + + + + \ No newline at end of file diff --git a/docs/html/index/Functions.html b/docs/html/index/Functions.html new file mode 100644 index 0000000..a249d51 --- /dev/null +++ b/docs/html/index/Functions.html @@ -0,0 +1,55 @@ + + +Function Index - CoreMark + + + + + + + +
Function Index
$#! · 0-9 · A · B · C · D · E · F · G · H · I · J · K · L · M · N · O · P · Q · R · S · T · U · V · W · X · Y · Z
C
 cmp_complex
 cmp_idx
 core_bench_matrix
 core_bench_state
 core_init_state
 core_list_find
 core_list_init
 core_list_insert
 core_list_mergesort
 core_list_remove
 core_list_reverse
 core_list_undo_remove
 core_start_parallel
 core_state_transition
 core_stop_parallel
 crc*
G
 get_seed
 get_time
I
 iterate
M
 main
 matrix_add_const
 matrix_mul_const
 matrix_mul_matrix
 matrix_mul_matrix_bitextract
 matrix_mul_vect
 matrix_sum
 matrix_test
P
 portable_fini
 portable_free
 portable_init
 portable_malloc
S
 start_time
 stop_time
T
 time_in_secs
+ +
ee_s32 cmp_complex(list_data *a,
list_data *b,
core_results *res)
Compare the data item in a list cell.
ee_s32 cmp_idx(list_data *a,
list_data *b,
core_results *res)
Compare the idx item in a list cell, and regen the data.
ee_u16 core_bench_matrix(mat_params *p,
ee_s16 seed,
ee_u16 crc)
Benchmark function
ee_u16 core_bench_state(ee_u32 blksize,
ee_u8 *memblock,
ee_s16 seed1,
ee_s16 seed2,
ee_s16 step,
ee_u16 crc)
Benchmark function
void core_init_state(ee_u32 size,
ee_s16 seed,
ee_u8 *p)
Initialize the input data for the state machine.
list_head *core_list_find(list_head *list,
list_data *info)
Find an item in the list
list_head *core_list_init(ee_u32 blksize,
list_head *memblock,
ee_s16 seed)
Initialize list with data.
list_head *core_list_insert_new(list_head *insert_point,
list_data *info,
list_head **memblock,
list_data **datablock ,
list_head *memblock_end,
list_data *datablock_end)
Insert an item to the list
list_head *core_list_mergesort(list_head *list,
list_cmp cmp,
core_results *res)
Sort the list in place without recursion.
list_head *core_list_remove(list_head *item)
Remove an item from the list.
list_head *core_list_reverse(list_head *list)
Reverse a list
list_head *core_list_undo_remove(list_head *item_removed,
list_head *item_modified)
Undo a remove operation.
Start benchmarking in a parallel context.
enum CORE_STATE core_state_transition(ee_u8 **instr ,
ee_u32 *transition_count)
Actual state machine.
Stop a parallel context execution of coremark, and gather the results.
Service functions to calculate 16b CRC code.
+ + + +
Get a values that cannot be determined at compile time.
CORE_TICKS get_time(void)
Return an abstract “ticks” number that signifies time on the system.
+ + + +
Run the benchmark for a specified number of iterations.
+ + + +
#if MAIN_HAS_NOARGC MAIN_RETURN_TYPE main(void)
Main entry routine for the benchmark.
void matrix_add_const(ee_u32 N,
MATDAT *A,
MATDAT val)
Add a constant value to all elements of a matrix.
void matrix_mul_const(ee_u32 N,
MATRES *C,
MATDAT *A,
MATDAT val)
Multiply a matrix by a constant.
void matrix_mul_matrix(ee_u32 N,
MATRES *C,
MATDAT *A,
MATDAT *B)
Multiply a matrix by a matrix.
void matrix_mul_matrix_bitextract(ee_u32 N,
MATRES *C,
MATDAT *A,
MATDAT *B)
Multiply a matrix by a matrix, and extract some bits from the result.
void matrix_mul_vect(ee_u32 N,
MATRES *C,
MATDAT *A,
MATDAT *B)
Multiply a matrix by a vector.
ee_s16 matrix_sum(ee_u32 N,
MATRES *C,
MATDAT clipval)
Calculate a function that depends on the values of elements in the matrix.
ee_s16 matrix_test(ee_u32 N,
MATRES *C,
MATDAT *A,
MATDAT *B,
MATDAT val)
Perform matrix manipulation.
+ + + +
void portable_fini(core_portable *p)
Target specific final code
void portable_free(void *p)
Provide free() functionality in a platform specific way.
void portable_init(core_portable *p,
int *argc,
char *argv[])
Target specific initialization code Test for some common mistakes.
void *portable_malloc(size_t size)
Provide malloc() functionality in a platform specific way.
+ + + +
void start_time(void)
This function will be called right before starting the timed portion of the benchmark.
void stop_time(void)
This function will be called right after ending the timed portion of the benchmark.
+ + + +
secs_ret time_in_secs(CORE_TICKS ticks)
Convert the value returned by get_time to seconds.
+ +
+ + + + + + + + + + + + \ No newline at end of file diff --git a/docs/html/index/General.html b/docs/html/index/General.html new file mode 100644 index 0000000..bd47b29 --- /dev/null +++ b/docs/html/index/General.html @@ -0,0 +1,75 @@ + + +Index - CoreMark + + + + + + + +
Index
$#! · 0-9 · A · B · C · D · E · F · G · H · I · J · K · L · M · N · O · P · Q · R · S · T · U · V · W · X · Y · Z
B
 Build Targets
linux/ core_portme.makPIC32/ core_portme.mak
 Building and running
C
 CC
 CFLAGS
linux/ core_portme.makPIC32/ core_portme.mak
 cmp_complex
 cmp_idx
 Configuration
coremark.hlinux/ core_portme.h
 core_bench_matrix
 core_bench_state
 core_init_state
 core_list_find
 core_list_init
 core_list_insert
 core_list_join.c
 core_list_mergesort
 core_list_remove
 core_list_reverse
 core_list_undo_remove
 core_main.c
 core_matrix.c
 core_portme.c
 core_portme.h
 core_portme.mak
linux/ core_portme.makPIC32/ core_portme.mak
 core_start_parallel
 core_state.c
 core_state_transition
 core_stop_parallel
 CORE_TICKS
 core_util.c
 CoreMark
 coremark.h
 crc*
 Credits
D
 default_num_contexts
 Description
core_list_join.ccore_matrix.ccore_state.ccoremark.hlinux/ core_portme.h
 Documentation
F
 Functions
core_list_join.ccore_main.ccore_matrix.ccore_state.ccore_util.c
G
 get_seed
 get_time
H
 HAS_FLOAT
 HAS_PRINTF
 HAS_STDIO
 HAS_TIME_H
I
 iterate
L
 Legal
 LFLAGS_END
linux/ core_portme.makPIC32/ core_portme.mak
 LOAD
 Log File Format
M
 main
 MAIN_HAS_NOARGC
 MAIN_HAS_NORETURN
 matrix_add_const
 matrix_mul_const
 matrix_mul_matrix
 matrix_mul_matrix_bitextract
 matrix_mul_vect
 matrix_sum
 matrix_test
 MEM_METHOD
 MULTITHREAD
O
 OPATH
linux/ core_portme.makPIC32/ core_portme.mak
 OUTFLAG
linux/ core_portme.makPIC32/ core_portme.mak
P
 PERL
linux/ core_portme.makPIC32/ core_portme.mak
 PORT_OBJS
linux/ core_portme.makPIC32/ core_portme.mak
 port_postbuild
linux/ core_portme.makPIC32/ core_portme.mak
 port_postload
linux/ core_portme.makPIC32/ core_portme.mak
 port_postrun
linux/ core_portme.makPIC32/ core_portme.mak
 port_prebuild
linux/ core_portme.makPIC32/ core_portme.mak
 port_preload
linux/ core_portme.makPIC32/ core_portme.mak
 port_prerun
linux/ core_portme.makPIC32/ core_portme.mak
 PORT_SRCS
 portable_fini
 portable_free
 portable_init
 portable_malloc
R
 Release Notes
 Reporting rules
 RUN
 Run rules
+ +
Download the release files from the www.coremark.org.
+ + + +
Use this flag to define compiler to use
Use this flag to define compiler options.
ee_s32 cmp_complex(list_data *a,
list_data *b,
core_results *res)
Compare the data item in a list cell.
ee_s32 cmp_idx(list_data *a,
list_data *b,
core_results *res)
Compare the idx item in a list cell, and regen the data.
ee_u16 core_bench_matrix(mat_params *p,
ee_s16 seed,
ee_u16 crc)
Benchmark function
ee_u16 core_bench_state(ee_u32 blksize,
ee_u8 *memblock,
ee_s16 seed1,
ee_s16 seed2,
ee_s16 step,
ee_u16 crc)
Benchmark function
void core_init_state(ee_u32 size,
ee_s16 seed,
ee_u8 *p)
Initialize the input data for the state machine.
list_head *core_list_find(list_head *list,
list_data *info)
Find an item in the list
list_head *core_list_init(ee_u32 blksize,
list_head *memblock,
ee_s16 seed)
Initialize list with data.
list_head *core_list_insert_new(list_head *insert_point,
list_data *info,
list_head **memblock,
list_data **datablock ,
list_head *memblock_end,
list_data *datablock_end)
Insert an item to the list
list_head *core_list_mergesort(list_head *list,
list_cmp cmp,
core_results *res)
Sort the list in place without recursion.
list_head *core_list_remove(list_head *item)
Remove an item from the list.
list_head *core_list_reverse(list_head *list)
Reverse a list
list_head *core_list_undo_remove(list_head *item_removed,
list_head *item_modified)
Undo a remove operation.
This file contains the framework to acquire a block of memory, seed initial parameters, tun t he benchmark and report the results.
Start benchmarking in a parallel context.
enum CORE_STATE core_state_transition(ee_u8 **instr ,
ee_u32 *transition_count)
Actual state machine.
Stop a parallel context execution of coremark, and gather the results.
Define type of return from the timing functions.
Service functions to calculate 16b CRC code.
Many thanks to all of the individuals who helped with the development or testing of CoreMark including (Sorted by company name)
+ + + +
extern ee_u32 default_num_contexts
Number of contexts to spawn in multicore context.
Benchmark using a linked list.
When you unpack the documentation (tar -vzxf coremark_version_docs.tgz) a docs folder will be created.
+ + + + + + + +
Get a values that cannot be determined at compile time.
CORE_TICKS get_time(void)
Return an abstract “ticks” number that signifies time on the system.
+ + + +
Define to 1 if the platform supports floating point.
Define to 1 if the platform has stdio.h and implements the printf function.
Define to 1 if the platform has stdio.h.
Define to 1 if platform has the time.h header file, and implementation of functions thereof.
+ + + +
Run the benchmark for a specified number of iterations.
+ + + +
See LICENSE.txt or the word document file under docs/LICENSE.doc.
Define any libraries needed for linking or other flags that should come at the end of the link line (e.g.
Define this flag if you need to load to a target, as in a cross compile environment.
The log files have the following format
+ + + +
#if MAIN_HAS_NOARGC MAIN_RETURN_TYPE main(void)
Main entry routine for the benchmark.
Needed if platform does not support getting arguments to main.
Needed if platform does not support returning a value from main.
void matrix_add_const(ee_u32 N,
MATDAT *A,
MATDAT val)
Add a constant value to all elements of a matrix.
void matrix_mul_const(ee_u32 N,
MATRES *C,
MATDAT *A,
MATDAT val)
Multiply a matrix by a constant.
void matrix_mul_matrix(ee_u32 N,
MATRES *C,
MATDAT *A,
MATDAT *B)
Multiply a matrix by a matrix.
void matrix_mul_matrix_bitextract(ee_u32 N,
MATRES *C,
MATDAT *A,
MATDAT *B)
Multiply a matrix by a matrix, and extract some bits from the result.
void matrix_mul_vect(ee_u32 N,
MATRES *C,
MATDAT *A,
MATDAT *B)
Multiply a matrix by a vector.
ee_s16 matrix_sum(ee_u32 N,
MATRES *C,
MATDAT clipval)
Calculate a function that depends on the values of elements in the matrix.
ee_s16 matrix_test(ee_u32 N,
MATRES *C,
MATDAT *A,
MATDAT *B,
MATDAT val)
Perform matrix manipulation.
Defines method to get a block of memry.
Define for parallel execution
+ + + +
Use this flag to define how to to get an executable (e.g -o)
+ + + +
Define perl executable to calculate the geomean if running separate.
Port specific object files can be added here
Generate any files that are needed after actual build end.
Do platform specific after load stuff.
Do platform specific after run stuff.
Generate any files that are needed before actual build starts.
Do platform specific before load stuff.
Do platform specific after run stuff.
Port specific source files can be added here
void portable_fini(core_portable *p)
Target specific final code
void portable_free(void *p)
Provide free() functionality in a platform specific way.
void portable_init(core_portable *p,
int *argc,
char *argv[])
Target specific initialization code Test for some common mistakes.
void *portable_malloc(size_t size)
Provide malloc() functionality in a platform specific way.
+ + + +
Version: 1.01
How to report results on a data sheet?
Define this flag if running does not consist of simple invocation of the binary.
What is and is not allowed.
+ +
+ + + + + + + + + + + + \ No newline at end of file diff --git a/docs/html/index/General2.html b/docs/html/index/General2.html new file mode 100644 index 0000000..3852ab5 --- /dev/null +++ b/docs/html/index/General2.html @@ -0,0 +1,47 @@ + + +Index - CoreMark + + + + + + + +
Index
$#! · 0-9 · A · B · C · D · E · F · G · H · I · J · K · L · M · N · O · P · Q · R · S · T · U · V · W · X · Y · Z
S
 secs_ret
 SEED_METHOD
 SEPARATE_COMPILE
linux/ core_portme.makPIC32/ core_portme.mak
 start_time
 stop_time
 Submitting results
T
 time_in_secs
 TIMER_RES_DIVIDER
 TOTAL_DATA_SIZE
 Types
U
 USE_CLOCK
 USE_FORK
 USE_PTHREAD
 USE_SOCKET
V
 Variables
linux/ core_portme.hlinux/ core_portme.makPIC32/ core_portme.mak
W
 Welcome
+ +
For machines that have floating point support, get number of seconds as a double.
Defines method to get seed values that cannot be computed at compile time.
Define if you need to separate compilation from link stage.
void start_time(void)
This function will be called right before starting the timed portion of the benchmark.
void stop_time(void)
This function will be called right after ending the timed portion of the benchmark.
CoreMark results can be submitted on the web.
+ + + +
secs_ret time_in_secs(CORE_TICKS ticks)
Convert the value returned by get_time to seconds.
Divider to trade off timer resolution and total time that can be measured.
Define total size for data algorithms will operate on
+ + + +
Define to 1 if platform has the time.h header file, and implementation of functions thereof.
Sample implementation for launching parallel contexts This implementation uses fork, waitpid, shmget,shmat and shmdt.
Sample implementation for launching parallel contexts This implementation uses pthread_thread_create and pthread_join.
Sample implementation for launching parallel contexts This implementation uses fork, socket, sendto and recvfrom
+ + + + + + + +
Copyright 2009 EEMBC All rights reserved.
+ +
+ + + + + + + + + + + + \ No newline at end of file diff --git a/docs/html/index/Types.html b/docs/html/index/Types.html new file mode 100644 index 0000000..1f44136 --- /dev/null +++ b/docs/html/index/Types.html @@ -0,0 +1,31 @@ + + +Type Index - CoreMark + + + + + + + +
Type Index
$#! · 0-9 · A · B · C · D · E · F · G · H · I · J · K · L · M · N · O · P · Q · R · S · T · U · V · W · X · Y · Z
S
 secs_ret
+ +
For machines that have floating point support, get number of seconds as a double.
+ +
+ + + + + + + + + + + + \ No newline at end of file diff --git a/docs/html/index/Variables.html b/docs/html/index/Variables.html new file mode 100644 index 0000000..8c050da --- /dev/null +++ b/docs/html/index/Variables.html @@ -0,0 +1,55 @@ + + +Variable Index - CoreMark + + + + + + + +
Variable Index
$#! · 0-9 · A · B · C · D · E · F · G · H · I · J · K · L · M · N · O · P · Q · R · S · T · U · V · W · X · Y · Z
C
 CC
 CFLAGS
linux/ core_portme.makPIC32/ core_portme.mak
D
 default_num_contexts
L
 LFLAGS_END
linux/ core_portme.makPIC32/ core_portme.mak
 LOAD
O
 OPATH
linux/ core_portme.makPIC32/ core_portme.mak
 OUTFLAG
linux/ core_portme.makPIC32/ core_portme.mak
P
 PERL
linux/ core_portme.makPIC32/ core_portme.mak
 PORT_OBJS
linux/ core_portme.makPIC32/ core_portme.mak
 PORT_SRCS
R
 RUN
S
 SEPARATE_COMPILE
linux/ core_portme.makPIC32/ core_portme.mak
+ +
Use this flag to define compiler to use
Use this flag to define compiler options.
+ + + +
extern ee_u32 default_num_contexts
Number of contexts to spawn in multicore context.
+ + + +
Define any libraries needed for linking or other flags that should come at the end of the link line (e.g.
Define this flag if you need to load to a target, as in a cross compile environment.
+ + + +
Use this flag to define how to to get an executable (e.g -o)
+ + + +
Define perl executable to calculate the geomean if running separate.
Port specific object files can be added here
Port specific source files can be added here
+ + + +
Define this flag if running does not consist of simple invocation of the binary.
+ + + +
Define if you need to separate compilation from link stage.
+ +
+ + + + + + + + + + + + \ No newline at end of file diff --git a/docs/html/javascript/main.js b/docs/html/javascript/main.js new file mode 100644 index 0000000..91991f5 --- /dev/null +++ b/docs/html/javascript/main.js @@ -0,0 +1,836 @@ +// This file is part of Natural Docs, which is Copyright (C) 2003-2008 Greg Valure +// Natural Docs is licensed under the GPL + + +// +// Browser Styles +// ____________________________________________________________________________ + +var agt=navigator.userAgent.toLowerCase(); +var browserType; +var browserVer; + +if (agt.indexOf("opera") != -1) + { + browserType = "Opera"; + + if (agt.indexOf("opera 7") != -1 || agt.indexOf("opera/7") != -1) + { browserVer = "Opera7"; } + else if (agt.indexOf("opera 8") != -1 || agt.indexOf("opera/8") != -1) + { browserVer = "Opera8"; } + else if (agt.indexOf("opera 9") != -1 || agt.indexOf("opera/9") != -1) + { browserVer = "Opera9"; } + } + +else if (agt.indexOf("applewebkit") != -1) + { + browserType = "Safari"; + + if (agt.indexOf("version/3") != -1) + { browserVer = "Safari3"; } + else if (agt.indexOf("safari/4") != -1) + { browserVer = "Safari2"; } + } + +else if (agt.indexOf("khtml") != -1) + { + browserType = "Konqueror"; + } + +else if (agt.indexOf("msie") != -1) + { + browserType = "IE"; + + if (agt.indexOf("msie 6") != -1) + { browserVer = "IE6"; } + else if (agt.indexOf("msie 7") != -1) + { browserVer = "IE7"; } + } + +else if (agt.indexOf("gecko") != -1) + { + browserType = "Firefox"; + + if (agt.indexOf("rv:1.7") != -1) + { browserVer = "Firefox1"; } + else if (agt.indexOf("rv:1.8)") != -1 || agt.indexOf("rv:1.8.0") != -1) + { browserVer = "Firefox15"; } + else if (agt.indexOf("rv:1.8.1") != -1) + { browserVer = "Firefox2"; } + } + + +// +// Support Functions +// ____________________________________________________________________________ + + +function GetXPosition(item) + { + var position = 0; + + if (item.offsetWidth != null) + { + while (item != document.body && item != null) + { + position += item.offsetLeft; + item = item.offsetParent; + }; + }; + + return position; + }; + + +function GetYPosition(item) + { + var position = 0; + + if (item.offsetWidth != null) + { + while (item != document.body && item != null) + { + position += item.offsetTop; + item = item.offsetParent; + }; + }; + + return position; + }; + + +function MoveToPosition(item, x, y) + { + // Opera 5 chokes on the px extension, so it can use the Microsoft one instead. + + if (item.style.left != null) + { + item.style.left = x + "px"; + item.style.top = y + "px"; + } + else if (item.style.pixelLeft != null) + { + item.style.pixelLeft = x; + item.style.pixelTop = y; + }; + }; + + +// +// Menu +// ____________________________________________________________________________ + + +function ToggleMenu(id) + { + if (!window.document.getElementById) + { return; }; + + var display = window.document.getElementById(id).style.display; + + if (display == "none") + { display = "block"; } + else + { display = "none"; } + + window.document.getElementById(id).style.display = display; + } + +function HideAllBut(ids, max) + { + if (document.getElementById) + { + ids.sort( function(a,b) { return a - b; } ); + var number = 1; + + while (number < max) + { + if (ids.length > 0 && number == ids[0]) + { ids.shift(); } + else + { + document.getElementById("MGroupContent" + number).style.display = "none"; + }; + + number++; + }; + }; + } + + +// +// Tooltips +// ____________________________________________________________________________ + + +var tooltipTimer = 0; + +function ShowTip(event, tooltipID, linkID) + { + if (tooltipTimer) + { clearTimeout(tooltipTimer); }; + + var docX = event.clientX + window.pageXOffset; + var docY = event.clientY + window.pageYOffset; + + var showCommand = "ReallyShowTip('" + tooltipID + "', '" + linkID + "', " + docX + ", " + docY + ")"; + + tooltipTimer = setTimeout(showCommand, 1000); + } + +function ReallyShowTip(tooltipID, linkID, docX, docY) + { + tooltipTimer = 0; + + var tooltip; + var link; + + if (document.getElementById) + { + tooltip = document.getElementById(tooltipID); + link = document.getElementById(linkID); + } +/* else if (document.all) + { + tooltip = eval("document.all['" + tooltipID + "']"); + link = eval("document.all['" + linkID + "']"); + } +*/ + if (tooltip) + { + var left = GetXPosition(link); + var top = GetYPosition(link); + top += link.offsetHeight; + + + // The fallback method is to use the mouse X and Y relative to the document. We use a separate if and test if its a number + // in case some browser snuck through the above if statement but didn't support everything. + + if (!isFinite(top) || top == 0) + { + left = docX; + top = docY; + } + + // Some spacing to get it out from under the cursor. + + top += 10; + + // Make sure the tooltip doesnt get smushed by being too close to the edge, or in some browsers, go off the edge of the + // page. We do it here because Konqueror does get offsetWidth right even if it doesnt get the positioning right. + + if (tooltip.offsetWidth != null) + { + var width = tooltip.offsetWidth; + var docWidth = document.body.clientWidth; + + if (left + width > docWidth) + { left = docWidth - width - 1; } + + // If there's a horizontal scroll bar we could go past zero because it's using the page width, not the window width. + if (left < 0) + { left = 0; }; + } + + MoveToPosition(tooltip, left, top); + tooltip.style.visibility = "visible"; + } + } + +function HideTip(tooltipID) + { + if (tooltipTimer) + { + clearTimeout(tooltipTimer); + tooltipTimer = 0; + } + + var tooltip; + + if (document.getElementById) + { tooltip = document.getElementById(tooltipID); } + else if (document.all) + { tooltip = eval("document.all['" + tooltipID + "']"); } + + if (tooltip) + { tooltip.style.visibility = "hidden"; } + } + + +// +// Blockquote fix for IE +// ____________________________________________________________________________ + + +function NDOnLoad() + { + if (browserVer == "IE6") + { + var scrollboxes = document.getElementsByTagName('blockquote'); + + if (scrollboxes.item(0)) + { + NDDoResize(); + window.onresize=NDOnResize; + }; + }; + }; + + +var resizeTimer = 0; + +function NDOnResize() + { + if (resizeTimer != 0) + { clearTimeout(resizeTimer); }; + + resizeTimer = setTimeout(NDDoResize, 250); + }; + + +function NDDoResize() + { + var scrollboxes = document.getElementsByTagName('blockquote'); + + var i; + var item; + + i = 0; + while (item = scrollboxes.item(i)) + { + item.style.width = 100; + i++; + }; + + i = 0; + while (item = scrollboxes.item(i)) + { + item.style.width = item.parentNode.offsetWidth; + i++; + }; + + clearTimeout(resizeTimer); + resizeTimer = 0; + } + + + +/* ________________________________________________________________________________________________________ + + Class: SearchPanel + ________________________________________________________________________________________________________ + + A class handling everything associated with the search panel. + + Parameters: + + name - The name of the global variable that will be storing this instance. Is needed to be able to set timeouts. + mode - The mode the search is going to work in. Pass CommandLineOption()>, so the + value will be something like "HTML" or "FramedHTML". + + ________________________________________________________________________________________________________ +*/ + + +function SearchPanel(name, mode, resultsPath) + { + if (!name || !mode || !resultsPath) + { alert("Incorrect parameters to SearchPanel."); }; + + + // Group: Variables + // ________________________________________________________________________ + + /* + var: name + The name of the global variable that will be storing this instance of the class. + */ + this.name = name; + + /* + var: mode + The mode the search is going to work in, such as "HTML" or "FramedHTML". + */ + this.mode = mode; + + /* + var: resultsPath + The relative path from the current HTML page to the results page directory. + */ + this.resultsPath = resultsPath; + + /* + var: keyTimeout + The timeout used between a keystroke and when a search is performed. + */ + this.keyTimeout = 0; + + /* + var: keyTimeoutLength + The length of in thousandths of a second. + */ + this.keyTimeoutLength = 500; + + /* + var: lastSearchValue + The last search string executed, or an empty string if none. + */ + this.lastSearchValue = ""; + + /* + var: lastResultsPage + The last results page. The value is only relevant if is set. + */ + this.lastResultsPage = ""; + + /* + var: deactivateTimeout + + The timeout used between when a control is deactivated and when the entire panel is deactivated. Is necessary + because a control may be deactivated in favor of another control in the same panel, in which case it should stay + active. + */ + this.deactivateTimout = 0; + + /* + var: deactivateTimeoutLength + The length of in thousandths of a second. + */ + this.deactivateTimeoutLength = 200; + + + + + // Group: DOM Elements + // ________________________________________________________________________ + + + // Function: DOMSearchField + this.DOMSearchField = function() + { return document.getElementById("MSearchField"); }; + + // Function: DOMSearchType + this.DOMSearchType = function() + { return document.getElementById("MSearchType"); }; + + // Function: DOMPopupSearchResults + this.DOMPopupSearchResults = function() + { return document.getElementById("MSearchResults"); }; + + // Function: DOMPopupSearchResultsWindow + this.DOMPopupSearchResultsWindow = function() + { return document.getElementById("MSearchResultsWindow"); }; + + // Function: DOMSearchPanel + this.DOMSearchPanel = function() + { return document.getElementById("MSearchPanel"); }; + + + + + // Group: Event Handlers + // ________________________________________________________________________ + + + /* + Function: OnSearchFieldFocus + Called when focus is added or removed from the search field. + */ + this.OnSearchFieldFocus = function(isActive) + { + this.Activate(isActive); + }; + + + /* + Function: OnSearchFieldChange + Called when the content of the search field is changed. + */ + this.OnSearchFieldChange = function() + { + if (this.keyTimeout) + { + clearTimeout(this.keyTimeout); + this.keyTimeout = 0; + }; + + var searchValue = this.DOMSearchField().value.replace(/ +/g, ""); + + if (searchValue != this.lastSearchValue) + { + if (searchValue != "") + { + this.keyTimeout = setTimeout(this.name + ".Search()", this.keyTimeoutLength); + } + else + { + if (this.mode == "HTML") + { this.DOMPopupSearchResultsWindow().style.display = "none"; }; + this.lastSearchValue = ""; + }; + }; + }; + + + /* + Function: OnSearchTypeFocus + Called when focus is added or removed from the search type. + */ + this.OnSearchTypeFocus = function(isActive) + { + this.Activate(isActive); + }; + + + /* + Function: OnSearchTypeChange + Called when the search type is changed. + */ + this.OnSearchTypeChange = function() + { + var searchValue = this.DOMSearchField().value.replace(/ +/g, ""); + + if (searchValue != "") + { + this.Search(); + }; + }; + + + + // Group: Action Functions + // ________________________________________________________________________ + + + /* + Function: CloseResultsWindow + Closes the results window. + */ + this.CloseResultsWindow = function() + { + this.DOMPopupSearchResultsWindow().style.display = "none"; + this.Activate(false, true); + }; + + + /* + Function: Search + Performs a search. + */ + this.Search = function() + { + this.keyTimeout = 0; + + var searchValue = this.DOMSearchField().value.replace(/^ +/, ""); + var searchTopic = this.DOMSearchType().value; + + var pageExtension = searchValue.substr(0,1); + + if (pageExtension.match(/^[a-z]/i)) + { pageExtension = pageExtension.toUpperCase(); } + else if (pageExtension.match(/^[0-9]/)) + { pageExtension = 'Numbers'; } + else + { pageExtension = "Symbols"; }; + + var resultsPage; + var resultsPageWithSearch; + var hasResultsPage; + + // indexSectionsWithContent is defined in searchdata.js + if (indexSectionsWithContent[searchTopic][pageExtension] == true) + { + resultsPage = this.resultsPath + '/' + searchTopic + pageExtension + '.html'; + resultsPageWithSearch = resultsPage+'?'+escape(searchValue); + hasResultsPage = true; + } + else + { + resultsPage = this.resultsPath + '/NoResults.html'; + resultsPageWithSearch = resultsPage; + hasResultsPage = false; + }; + + var resultsFrame; + if (this.mode == "HTML") + { resultsFrame = window.frames.MSearchResults; } + else if (this.mode == "FramedHTML") + { resultsFrame = window.top.frames['Content']; }; + + + if (resultsPage != this.lastResultsPage || + + // Bug in IE. If everything becomes hidden in a run, none of them will be able to be reshown in the next for some + // reason. It counts the right number of results, and you can even read the display as "block" after setting it, but it + // just doesn't work in IE 6 or IE 7. So if we're on the right page but the previous search had no results, reload the + // page anyway to get around the bug. + (browserType == "IE" && hasResultsPage && + (!resultsFrame.searchResults || resultsFrame.searchResults.lastMatchCount == 0)) ) + + { + resultsFrame.location.href = resultsPageWithSearch; + } + + // So if the results page is right and there's no IE bug, reperform the search on the existing page. We have to check if there + // are results because NoResults.html doesn't have any JavaScript, and it would be useless to do anything on that page even + // if it did. + else if (hasResultsPage) + { + // We need to check if this exists in case the frame is present but didn't finish loading. + if (resultsFrame.searchResults) + { resultsFrame.searchResults.Search(searchValue); } + + // Otherwise just reload instead of waiting. + else + { resultsFrame.location.href = resultsPageWithSearch; }; + }; + + + var domPopupSearchResultsWindow = this.DOMPopupSearchResultsWindow(); + + if (this.mode == "HTML" && domPopupSearchResultsWindow.style.display != "block") + { + var domSearchType = this.DOMSearchType(); + + var left = GetXPosition(domSearchType); + var top = GetYPosition(domSearchType) + domSearchType.offsetHeight; + + MoveToPosition(domPopupSearchResultsWindow, left, top); + domPopupSearchResultsWindow.style.display = 'block'; + }; + + + this.lastSearchValue = searchValue; + this.lastResultsPage = resultsPage; + }; + + + + // Group: Activation Functions + // Functions that handle whether the entire panel is active or not. + // ________________________________________________________________________ + + + /* + Function: Activate + + Activates or deactivates the search panel, resetting things to their default values if necessary. You can call this on every + control's OnBlur() and it will handle not deactivating the entire panel when focus is just switching between them transparently. + + Parameters: + + isActive - Whether you're activating or deactivating the panel. + ignoreDeactivateDelay - Set if you're positive the action will deactivate the panel and thus want to skip the delay. + */ + this.Activate = function(isActive, ignoreDeactivateDelay) + { + // We want to ignore isActive being false while the results window is open. + if (isActive || (this.mode == "HTML" && this.DOMPopupSearchResultsWindow().style.display == "block")) + { + if (this.inactivateTimeout) + { + clearTimeout(this.inactivateTimeout); + this.inactivateTimeout = 0; + }; + + this.DOMSearchPanel().className = 'MSearchPanelActive'; + + var searchField = this.DOMSearchField(); + + if (searchField.value == 'Search') + { searchField.value = ""; } + } + else if (!ignoreDeactivateDelay) + { + this.inactivateTimeout = setTimeout(this.name + ".InactivateAfterTimeout()", this.inactivateTimeoutLength); + } + else + { + this.InactivateAfterTimeout(); + }; + }; + + + /* + Function: InactivateAfterTimeout + + Called by , which is set by . Inactivation occurs on a timeout because a control may + receive OnBlur() when focus is really transferring to another control in the search panel. In this case we don't want to + actually deactivate the panel because not only would that cause a visible flicker but it could also reset the search value. + So by doing it on a timeout instead, there's a short period where the second control's OnFocus() can cancel the deactivation. + */ + this.InactivateAfterTimeout = function() + { + this.inactivateTimeout = 0; + + this.DOMSearchPanel().className = 'MSearchPanelInactive'; + this.DOMSearchField().value = "Search"; + + this.lastSearchValue = ""; + this.lastResultsPage = ""; + }; + }; + + + + +/* ________________________________________________________________________________________________________ + + Class: SearchResults + _________________________________________________________________________________________________________ + + The class that handles everything on the search results page. + _________________________________________________________________________________________________________ +*/ + + +function SearchResults(name, mode) + { + /* + var: mode + The mode the search is going to work in, such as "HTML" or "FramedHTML". + */ + this.mode = mode; + + /* + var: lastMatchCount + The number of matches from the last run of . + */ + this.lastMatchCount = 0; + + + /* + Function: Toggle + Toggles the visibility of the passed element ID. + */ + this.Toggle = function(id) + { + if (this.mode == "FramedHTML") + { return; }; + + var parentElement = document.getElementById(id); + + var element = parentElement.firstChild; + + while (element && element != parentElement) + { + if (element.nodeName == 'DIV' && element.className == 'ISubIndex') + { + if (element.style.display == 'block') + { element.style.display = "none"; } + else + { element.style.display = 'block'; } + }; + + if (element.nodeName == 'DIV' && element.hasChildNodes()) + { element = element.firstChild; } + else if (element.nextSibling) + { element = element.nextSibling; } + else + { + do + { + element = element.parentNode; + } + while (element && element != parentElement && !element.nextSibling); + + if (element && element != parentElement) + { element = element.nextSibling; }; + }; + }; + }; + + + /* + Function: Search + + Searches for the passed string. If there is no parameter, it takes it from the URL query. + + Always returns true, since other documents may try to call it and that may or may not be possible. + */ + this.Search = function(search) + { + if (!search) + { + search = window.location.search; + search = search.substring(1); // Remove the leading ? + search = unescape(search); + }; + + search = search.replace(/^ +/, ""); + search = search.replace(/ +$/, ""); + search = search.toLowerCase(); + + if (search.match(/[^a-z0-9]/)) // Just a little speedup so it doesn't have to go through the below unnecessarily. + { + search = search.replace(/\_/g, "_und"); + search = search.replace(/\ +/gi, "_spc"); + search = search.replace(/\~/g, "_til"); + search = search.replace(/\!/g, "_exc"); + search = search.replace(/\@/g, "_att"); + search = search.replace(/\#/g, "_num"); + search = search.replace(/\$/g, "_dol"); + search = search.replace(/\%/g, "_pct"); + search = search.replace(/\^/g, "_car"); + search = search.replace(/\&/g, "_amp"); + search = search.replace(/\*/g, "_ast"); + search = search.replace(/\(/g, "_lpa"); + search = search.replace(/\)/g, "_rpa"); + search = search.replace(/\-/g, "_min"); + search = search.replace(/\+/g, "_plu"); + search = search.replace(/\=/g, "_equ"); + search = search.replace(/\{/g, "_lbc"); + search = search.replace(/\}/g, "_rbc"); + search = search.replace(/\[/g, "_lbk"); + search = search.replace(/\]/g, "_rbk"); + search = search.replace(/\:/g, "_col"); + search = search.replace(/\;/g, "_sco"); + search = search.replace(/\"/g, "_quo"); + search = search.replace(/\'/g, "_apo"); + search = search.replace(/\/g, "_ran"); + search = search.replace(/\,/g, "_com"); + search = search.replace(/\./g, "_per"); + search = search.replace(/\?/g, "_que"); + search = search.replace(/\//g, "_sla"); + search = search.replace(/[^a-z0-9\_]i/gi, "_zzz"); + }; + + var resultRows = document.getElementsByTagName("div"); + var matches = 0; + + var i = 0; + while (i < resultRows.length) + { + var row = resultRows.item(i); + + if (row.className == "SRResult") + { + var rowMatchName = row.id.toLowerCase(); + rowMatchName = rowMatchName.replace(/^sr\d*_/, ''); + + if (search.length <= rowMatchName.length && rowMatchName.substr(0, search.length) == search) + { + row.style.display = "block"; + matches++; + } + else + { row.style.display = "none"; }; + }; + + i++; + }; + + document.getElementById("Searching").style.display="none"; + + if (matches == 0) + { document.getElementById("NoMatches").style.display="block"; } + else + { document.getElementById("NoMatches").style.display="none"; } + + this.lastMatchCount = matches; + + return true; + }; + }; + diff --git a/docs/html/javascript/searchdata.js b/docs/html/javascript/searchdata.js new file mode 100644 index 0000000..901318e --- /dev/null +++ b/docs/html/javascript/searchdata.js @@ -0,0 +1,212 @@ +var indexSectionsWithContent = { + "General": { + "Symbols": false, + "Numbers": false, + "A": false, + "B": false, + "C": true, + "D": true, + "E": false, + "F": true, + "G": true, + "H": false, + "I": true, + "J": false, + "K": false, + "L": false, + "M": true, + "N": false, + "O": false, + "P": false, + "Q": false, + "R": false, + "S": true, + "T": true, + "U": false, + "V": false, + "W": false, + "X": false, + "Y": false, + "Z": false + }, + "Variables": { + "Symbols": false, + "Numbers": false, + "A": false, + "B": false, + "C": true, + "D": true, + "E": false, + "F": false, + "G": false, + "H": false, + "I": false, + "J": false, + "K": false, + "L": true, + "M": false, + "N": false, + "O": true, + "P": true, + "Q": false, + "R": true, + "S": true, + "T": false, + "U": false, + "V": false, + "W": false, + "X": false, + "Y": false, + "Z": false + }, + "Functions": { + "Symbols": false, + "Numbers": false, + "A": false, + "B": false, + "C": true, + "D": false, + "E": false, + "F": false, + "G": true, + "H": false, + "I": true, + "J": false, + "K": false, + "L": false, + "M": true, + "N": false, + "O": false, + "P": true, + "Q": false, + "R": false, + "S": true, + "T": true, + "U": false, + "V": false, + "W": false, + "X": false, + "Y": false, + "Z": false + }, + "Files": { + "Symbols": false, + "Numbers": false, + "A": false, + "B": false, + "C": true, + "D": false, + "E": false, + "F": false, + "G": false, + "H": false, + "I": false, + "J": false, + "K": false, + "L": false, + "M": false, + "N": false, + "O": false, + "P": false, + "Q": false, + "R": true, + "S": false, + "T": false, + "U": false, + "V": false, + "W": false, + "X": false, + "Y": false, + "Z": false + }, + "Configuration": { + "Symbols": false, + "Numbers": false, + "A": false, + "B": false, + "C": true, + "D": false, + "E": false, + "F": false, + "G": false, + "H": true, + "I": false, + "J": false, + "K": false, + "L": false, + "M": true, + "N": false, + "O": false, + "P": false, + "Q": false, + "R": false, + "S": true, + "T": true, + "U": true, + "V": false, + "W": false, + "X": false, + "Y": false, + "Z": false + }, + "Types": { + "Symbols": false, + "Numbers": false, + "A": false, + "B": false, + "C": false, + "D": false, + "E": false, + "F": false, + "G": false, + "H": false, + "I": false, + "J": false, + "K": false, + "L": false, + "M": false, + "N": false, + "O": false, + "P": false, + "Q": false, + "R": false, + "S": true, + "T": false, + "U": false, + "V": false, + "W": false, + "X": false, + "Y": false, + "Z": false + }, + "BuildTargets": { + "Symbols": false, + "Numbers": false, + "A": false, + "B": false, + "C": false, + "D": false, + "E": false, + "F": false, + "G": false, + "H": false, + "I": false, + "J": false, + "K": false, + "L": false, + "M": false, + "N": false, + "O": false, + "P": true, + "Q": false, + "R": false, + "S": false, + "T": false, + "U": false, + "V": false, + "W": false, + "X": false, + "Y": false, + "Z": false + } + } \ No newline at end of file diff --git a/docs/html/search/BuildTargetsP.html b/docs/html/search/BuildTargetsP.html new file mode 100644 index 0000000..65e741d --- /dev/null +++ b/docs/html/search/BuildTargetsP.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/ConfigurationC.html b/docs/html/search/ConfigurationC.html new file mode 100644 index 0000000..84b49ca --- /dev/null +++ b/docs/html/search/ConfigurationC.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/ConfigurationH.html b/docs/html/search/ConfigurationH.html new file mode 100644 index 0000000..3b0c392 --- /dev/null +++ b/docs/html/search/ConfigurationH.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/ConfigurationM.html b/docs/html/search/ConfigurationM.html new file mode 100644 index 0000000..022606f --- /dev/null +++ b/docs/html/search/ConfigurationM.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/ConfigurationS.html b/docs/html/search/ConfigurationS.html new file mode 100644 index 0000000..d26de19 --- /dev/null +++ b/docs/html/search/ConfigurationS.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/ConfigurationT.html b/docs/html/search/ConfigurationT.html new file mode 100644 index 0000000..183daf1 --- /dev/null +++ b/docs/html/search/ConfigurationT.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/ConfigurationU.html b/docs/html/search/ConfigurationU.html new file mode 100644 index 0000000..d9b46a5 --- /dev/null +++ b/docs/html/search/ConfigurationU.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/ConfigurationsH.html b/docs/html/search/ConfigurationsH.html new file mode 100644 index 0000000..ade2ab7 --- /dev/null +++ b/docs/html/search/ConfigurationsH.html @@ -0,0 +1,20 @@ + + + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/ConfigurationsM.html b/docs/html/search/ConfigurationsM.html new file mode 100644 index 0000000..baa1892 --- /dev/null +++ b/docs/html/search/ConfigurationsM.html @@ -0,0 +1,20 @@ + + + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/ConfigurationsS.html b/docs/html/search/ConfigurationsS.html new file mode 100644 index 0000000..ceb8abf --- /dev/null +++ b/docs/html/search/ConfigurationsS.html @@ -0,0 +1,20 @@ + + + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/ConfigurationsT.html b/docs/html/search/ConfigurationsT.html new file mode 100644 index 0000000..ef13810 --- /dev/null +++ b/docs/html/search/ConfigurationsT.html @@ -0,0 +1,20 @@ + + + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/FilesC.html b/docs/html/search/FilesC.html new file mode 100644 index 0000000..e2b01c4 --- /dev/null +++ b/docs/html/search/FilesC.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/FilesR.html b/docs/html/search/FilesR.html new file mode 100644 index 0000000..6202fb7 --- /dev/null +++ b/docs/html/search/FilesR.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/FunctionsC.html b/docs/html/search/FunctionsC.html new file mode 100644 index 0000000..43993db --- /dev/null +++ b/docs/html/search/FunctionsC.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/FunctionsG.html b/docs/html/search/FunctionsG.html new file mode 100644 index 0000000..217e854 --- /dev/null +++ b/docs/html/search/FunctionsG.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/FunctionsI.html b/docs/html/search/FunctionsI.html new file mode 100644 index 0000000..f17354d --- /dev/null +++ b/docs/html/search/FunctionsI.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/FunctionsM.html b/docs/html/search/FunctionsM.html new file mode 100644 index 0000000..345e2ba --- /dev/null +++ b/docs/html/search/FunctionsM.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/FunctionsP.html b/docs/html/search/FunctionsP.html new file mode 100644 index 0000000..c4b9d2d --- /dev/null +++ b/docs/html/search/FunctionsP.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/FunctionsS.html b/docs/html/search/FunctionsS.html new file mode 100644 index 0000000..33dfa5f --- /dev/null +++ b/docs/html/search/FunctionsS.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/FunctionsT.html b/docs/html/search/FunctionsT.html new file mode 100644 index 0000000..65ae37c --- /dev/null +++ b/docs/html/search/FunctionsT.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/GeneralB.html b/docs/html/search/GeneralB.html new file mode 100644 index 0000000..66e27e4 --- /dev/null +++ b/docs/html/search/GeneralB.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/GeneralC.html b/docs/html/search/GeneralC.html new file mode 100644 index 0000000..f1ac9d2 --- /dev/null +++ b/docs/html/search/GeneralC.html @@ -0,0 +1,18 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/docs/html/search/GeneralD.html b/docs/html/search/GeneralD.html new file mode 100644 index 0000000..b3c2100 --- /dev/null +++ b/docs/html/search/GeneralD.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/GeneralF.html b/docs/html/search/GeneralF.html new file mode 100644 index 0000000..126a24c --- /dev/null +++ b/docs/html/search/GeneralF.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/GeneralG.html b/docs/html/search/GeneralG.html new file mode 100644 index 0000000..217e854 --- /dev/null +++ b/docs/html/search/GeneralG.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/GeneralH.html b/docs/html/search/GeneralH.html new file mode 100644 index 0000000..3b0c392 --- /dev/null +++ b/docs/html/search/GeneralH.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/GeneralI.html b/docs/html/search/GeneralI.html new file mode 100644 index 0000000..f17354d --- /dev/null +++ b/docs/html/search/GeneralI.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/GeneralL.html b/docs/html/search/GeneralL.html new file mode 100644 index 0000000..22a700c --- /dev/null +++ b/docs/html/search/GeneralL.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/GeneralM.html b/docs/html/search/GeneralM.html new file mode 100644 index 0000000..57f55b2 --- /dev/null +++ b/docs/html/search/GeneralM.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/GeneralO.html b/docs/html/search/GeneralO.html new file mode 100644 index 0000000..b14f180 --- /dev/null +++ b/docs/html/search/GeneralO.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/GeneralP.html b/docs/html/search/GeneralP.html new file mode 100644 index 0000000..063a6c1 --- /dev/null +++ b/docs/html/search/GeneralP.html @@ -0,0 +1,18 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/docs/html/search/GeneralR.html b/docs/html/search/GeneralR.html new file mode 100644 index 0000000..24f3395 --- /dev/null +++ b/docs/html/search/GeneralR.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/GeneralS.html b/docs/html/search/GeneralS.html new file mode 100644 index 0000000..a18c407 --- /dev/null +++ b/docs/html/search/GeneralS.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/GeneralT.html b/docs/html/search/GeneralT.html new file mode 100644 index 0000000..a2fde7e --- /dev/null +++ b/docs/html/search/GeneralT.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/GeneralU.html b/docs/html/search/GeneralU.html new file mode 100644 index 0000000..d9b46a5 --- /dev/null +++ b/docs/html/search/GeneralU.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/GeneralV.html b/docs/html/search/GeneralV.html new file mode 100644 index 0000000..9c53066 --- /dev/null +++ b/docs/html/search/GeneralV.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/GeneralW.html b/docs/html/search/GeneralW.html new file mode 100644 index 0000000..e22dcb0 --- /dev/null +++ b/docs/html/search/GeneralW.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/NoResults.html b/docs/html/search/NoResults.html new file mode 100644 index 0000000..49e3859 --- /dev/null +++ b/docs/html/search/NoResults.html @@ -0,0 +1,13 @@ + + + + + + + + + + +
No Matches
\ No newline at end of file diff --git a/docs/html/search/TypesS.html b/docs/html/search/TypesS.html new file mode 100644 index 0000000..3d87649 --- /dev/null +++ b/docs/html/search/TypesS.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/VariablesC.html b/docs/html/search/VariablesC.html new file mode 100644 index 0000000..d3bdfef --- /dev/null +++ b/docs/html/search/VariablesC.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/VariablesD.html b/docs/html/search/VariablesD.html new file mode 100644 index 0000000..d4b961d --- /dev/null +++ b/docs/html/search/VariablesD.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/VariablesL.html b/docs/html/search/VariablesL.html new file mode 100644 index 0000000..09e4b9a --- /dev/null +++ b/docs/html/search/VariablesL.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/VariablesO.html b/docs/html/search/VariablesO.html new file mode 100644 index 0000000..b14f180 --- /dev/null +++ b/docs/html/search/VariablesO.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/VariablesP.html b/docs/html/search/VariablesP.html new file mode 100644 index 0000000..c687999 --- /dev/null +++ b/docs/html/search/VariablesP.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/VariablesR.html b/docs/html/search/VariablesR.html new file mode 100644 index 0000000..9cd771d --- /dev/null +++ b/docs/html/search/VariablesR.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/search/VariablesS.html b/docs/html/search/VariablesS.html new file mode 100644 index 0000000..a1280a7 --- /dev/null +++ b/docs/html/search/VariablesS.html @@ -0,0 +1,18 @@ + + + + + + + + + + +
Loading...
Searching...
No Matches
\ No newline at end of file diff --git a/docs/html/styles/1.css b/docs/html/styles/1.css new file mode 100644 index 0000000..d5a8bd6 --- /dev/null +++ b/docs/html/styles/1.css @@ -0,0 +1,767 @@ +/* + IMPORTANT: If you're editing this file in the output directory of one of + your projects, your changes will be overwritten the next time you run + Natural Docs. Instead, copy this file to your project directory, make your + changes, and you can use it with -s. Even better would be to make a CSS + file in your project directory with only your changes, which you can then + use with -s [original style] [your changes]. + + On the other hand, if you're editing this file in the Natural Docs styles + directory, the changes will automatically be applied to all your projects + that use this style the next time Natural Docs is run on them. + + This file is part of Natural Docs, which is Copyright (C) 2003-2008 Greg Valure + Natural Docs is licensed under the GPL +*/ + +body { + font: 10pt Verdana, Arial, sans-serif; + color: #000000; + margin: 0; padding: 0; + } + +.ContentPage, +.IndexPage, +.FramedMenuPage { + background-color: #E8E8E8; + } +.FramedContentPage, +.FramedIndexPage, +.FramedSearchResultsPage, +.PopupSearchResultsPage { + background-color: #FFFFFF; + } + + +a:link, +a:visited { color: #900000; text-decoration: none } +a:hover { color: #900000; text-decoration: underline } +a:active { color: #FF0000; text-decoration: underline } + +td { + vertical-align: top } + +img { border: 0; } + + +/* + Comment out this line to use web-style paragraphs (blank line between + paragraphs, no indent) instead of print-style paragraphs (no blank line, + indented.) +*/ +p { + text-indent: 5ex; margin: 0 } + + +/* Can't use something like display: none or it won't break. */ +.HB { + font-size: 1px; + visibility: hidden; + } + +/* Blockquotes are used as containers for things that may need to scroll. */ +blockquote { + padding: 0; + margin: 0; + overflow: auto; + } + + +.Firefox1 blockquote { + padding-bottom: .5em; + } + +/* Turn off scrolling when printing. */ +@media print { + blockquote { + overflow: visible; + } + .IE blockquote { + width: auto; + } + } + + + +#Menu { + font-size: 9pt; + padding: 10px 0 0 0; + } +.ContentPage #Menu, +.IndexPage #Menu { + position: absolute; + top: 0; + left: 0; + width: 31ex; + overflow: hidden; + } +.ContentPage .Firefox #Menu, +.IndexPage .Firefox #Menu { + width: 27ex; + } + + + .MTitle { + font-size: 16pt; font-weight: bold; font-variant: small-caps; + text-align: center; + padding: 5px 10px 15px 10px; + border-bottom: 1px dotted #000000; + margin-bottom: 15px } + + .MSubTitle { + font-size: 9pt; font-weight: normal; font-variant: normal; + margin-top: 1ex; margin-bottom: 5px } + + + .MEntry a:link, + .MEntry a:hover, + .MEntry a:visited { color: #606060; margin-right: 0 } + .MEntry a:active { color: #A00000; margin-right: 0 } + + + .MGroup { + font-variant: small-caps; font-weight: bold; + margin: 1em 0 1em 10px; + } + + .MGroupContent { + font-variant: normal; font-weight: normal } + + .MGroup a:link, + .MGroup a:hover, + .MGroup a:visited { color: #545454; margin-right: 10px } + .MGroup a:active { color: #A00000; margin-right: 10px } + + + .MFile, + .MText, + .MLink, + .MIndex { + padding: 1px 17px 2px 10px; + margin: .25em 0 .25em 0; + } + + .MText { + font-size: 8pt; font-style: italic } + + .MLink { + font-style: italic } + + #MSelected { + color: #000000; background-color: #FFFFFF; + /* Replace padding with border. */ + padding: 0 10px 0 10px; + border-width: 1px 2px 2px 0; border-style: solid; border-color: #000000; + margin-right: 5px; + } + + /* Close off the left side when its in a group. */ + .MGroup #MSelected { + padding-left: 9px; border-left-width: 1px } + + /* A treat for Mozilla users. Blatantly non-standard. Will be replaced with CSS 3 attributes when finalized/supported. */ + .Firefox #MSelected { + -moz-border-radius-topright: 10px; + -moz-border-radius-bottomright: 10px } + .Firefox .MGroup #MSelected { + -moz-border-radius-topleft: 10px; + -moz-border-radius-bottomleft: 10px } + + + #MSearchPanel { + padding: 0px 6px; + margin: .25em 0; + } + + + #MSearchField { + font: italic 9pt Verdana, sans-serif; + color: #606060; + background-color: #E8E8E8; + border: none; + padding: 2px 4px; + width: 100%; + } + /* Only Opera gets it right. */ + .Firefox #MSearchField, + .IE #MSearchField, + .Safari #MSearchField { + width: 94%; + } + .Opera9 #MSearchField, + .Konqueror #MSearchField { + width: 97%; + } + .FramedMenuPage .Firefox #MSearchField, + .FramedMenuPage .Safari #MSearchField, + .FramedMenuPage .Konqueror #MSearchField { + width: 98%; + } + + /* Firefox doesn't do this right in frames without #MSearchPanel added on. + It's presence doesn't hurt anything other browsers. */ + #MSearchPanel.MSearchPanelInactive:hover #MSearchField { + background-color: #FFFFFF; + border: 1px solid #C0C0C0; + padding: 1px 3px; + } + .MSearchPanelActive #MSearchField { + background-color: #FFFFFF; + border: 1px solid #C0C0C0; + font-style: normal; + padding: 1px 3px; + } + + #MSearchType { + visibility: hidden; + font: 8pt Verdana, sans-serif; + width: 98%; + padding: 0; + border: 1px solid #C0C0C0; + } + .MSearchPanelActive #MSearchType, + /* As mentioned above, Firefox doesn't do this right in frames without #MSearchPanel added on. */ + #MSearchPanel.MSearchPanelInactive:hover #MSearchType, + #MSearchType:focus { + visibility: visible; + color: #606060; + } + #MSearchType option#MSearchEverything { + font-weight: bold; + } + + .Opera8 .MSearchPanelInactive:hover, + .Opera8 .MSearchPanelActive { + margin-left: -1px; + } + + + iframe#MSearchResults { + width: 60ex; + height: 15em; + } + #MSearchResultsWindow { + display: none; + position: absolute; + left: 0; top: 0; + border: 1px solid #000000; + background-color: #E8E8E8; + } + #MSearchResultsWindowClose { + font-weight: bold; + font-size: 8pt; + display: block; + padding: 2px 5px; + } + #MSearchResultsWindowClose:link, + #MSearchResultsWindowClose:visited { + color: #000000; + text-decoration: none; + } + #MSearchResultsWindowClose:active, + #MSearchResultsWindowClose:hover { + color: #800000; + text-decoration: none; + background-color: #F4F4F4; + } + + + + +#Content { + padding-bottom: 15px; + } + +.ContentPage #Content { + border-width: 0 0 1px 1px; + border-style: solid; + border-color: #000000; + background-color: #FFFFFF; + font-size: 9pt; /* To make 31ex match the menu's 31ex. */ + margin-left: 31ex; + } +.ContentPage .Firefox #Content { + margin-left: 27ex; + } + + + + .CTopic { + font-size: 10pt; + margin-bottom: 3em; + } + + + .CTitle { + font-size: 12pt; font-weight: bold; + border-width: 0 0 1px 0; border-style: solid; border-color: #A0A0A0; + margin: 0 15px .5em 15px } + + .CGroup .CTitle { + font-size: 16pt; font-variant: small-caps; + padding-left: 15px; padding-right: 15px; + border-width: 0 0 2px 0; border-color: #000000; + margin-left: 0; margin-right: 0 } + + .CClass .CTitle, + .CInterface .CTitle, + .CDatabase .CTitle, + .CDatabaseTable .CTitle, + .CSection .CTitle { + font-size: 18pt; + color: #FFFFFF; background-color: #A0A0A0; + padding: 10px 15px 10px 15px; + border-width: 2px 0; border-color: #000000; + margin-left: 0; margin-right: 0 } + + #MainTopic .CTitle { + font-size: 20pt; + color: #FFFFFF; background-color: #7070C0; + padding: 10px 15px 10px 15px; + border-width: 0 0 3px 0; border-color: #000000; + margin-left: 0; margin-right: 0 } + + .CBody { + margin-left: 15px; margin-right: 15px } + + + .CToolTip { + position: absolute; visibility: hidden; + left: 0; top: 0; + background-color: #FFFFE0; + padding: 5px; + border-width: 1px 2px 2px 1px; border-style: solid; border-color: #000000; + font-size: 8pt; + } + + .Opera .CToolTip { + max-width: 98%; + } + + /* Scrollbars would be useless. */ + .CToolTip blockquote { + overflow: hidden; + } + .IE6 .CToolTip blockquote { + overflow: visible; + } + + .CHeading { + font-weight: bold; font-size: 10pt; + margin: 1.5em 0 .5em 0; + } + + .CBody pre { + font: 10pt "Courier New", Courier, monospace; + margin: 1em 0; + } + + .CBody ul { + /* I don't know why CBody's margin doesn't apply, but it's consistent across browsers so whatever. + Reapply it here as padding. */ + padding-left: 15px; padding-right: 15px; + margin: .5em 5ex .5em 5ex; + } + + .CDescriptionList { + margin: .5em 5ex 0 5ex } + + .CDLEntry { + font: 10pt "Courier New", Courier, monospace; color: #808080; + padding-bottom: .25em; + white-space: nowrap } + + .CDLDescription { + font-size: 10pt; /* For browsers that don't inherit correctly, like Opera 5. */ + padding-bottom: .5em; padding-left: 5ex } + + + .CTopic img { + text-align: center; + display: block; + margin: 1em auto; + } + .CImageCaption { + font-variant: small-caps; + font-size: 8pt; + color: #808080; + text-align: center; + position: relative; + top: 1em; + } + + .CImageLink { + color: #808080; + font-style: italic; + } + a.CImageLink:link, + a.CImageLink:visited, + a.CImageLink:hover { color: #808080 } + + + + + +.Prototype { + font: 10pt "Courier New", Courier, monospace; + padding: 5px 3ex; + border-width: 1px; border-style: solid; + margin: 0 5ex 1.5em 5ex; + } + + .Prototype td { + font-size: 10pt; + } + + .PDefaultValue, + .PDefaultValuePrefix, + .PTypePrefix { + color: #8F8F8F; + } + .PTypePrefix { + text-align: right; + } + .PAfterParameters { + vertical-align: bottom; + } + + .IE .Prototype table { + padding: 0; + } + + .CFunction .Prototype { + background-color: #F4F4F4; border-color: #D0D0D0 } + .CProperty .Prototype { + background-color: #F4F4FF; border-color: #C0C0E8 } + .CVariable .Prototype { + background-color: #FFFFF0; border-color: #E0E0A0 } + + .CClass .Prototype { + border-width: 1px 2px 2px 1px; border-style: solid; border-color: #A0A0A0; + background-color: #F4F4F4; + } + .CInterface .Prototype { + border-width: 1px 2px 2px 1px; border-style: solid; border-color: #A0A0D0; + background-color: #F4F4FF; + } + + .CDatabaseIndex .Prototype, + .CConstant .Prototype { + background-color: #D0D0D0; border-color: #000000 } + .CType .Prototype, + .CEnumeration .Prototype { + background-color: #FAF0F0; border-color: #E0B0B0; + } + .CDatabaseTrigger .Prototype, + .CEvent .Prototype, + .CDelegate .Prototype { + background-color: #F0FCF0; border-color: #B8E4B8 } + + .CToolTip .Prototype { + margin: 0 0 .5em 0; + white-space: nowrap; + } + + + + + +.Summary { + margin: 1.5em 5ex 0 5ex } + + .STitle { + font-size: 12pt; font-weight: bold; + margin-bottom: .5em } + + + .SBorder { + background-color: #FFFFF0; + padding: 15px; + border: 1px solid #C0C060 } + + /* In a frame IE 6 will make them too long unless you set the width to 100%. Without frames it will be correct without a width + or slightly too long (but not enough to scroll) with a width. This arbitrary weirdness simply astounds me. IE 7 has the same + problem with frames, haven't tested it without. */ + .FramedContentPage .IE .SBorder { + width: 100% } + + /* A treat for Mozilla users. Blatantly non-standard. Will be replaced with CSS 3 attributes when finalized/supported. */ + .Firefox .SBorder { + -moz-border-radius: 20px } + + + .STable { + font-size: 9pt; width: 100% } + + .SEntry { + width: 30% } + .SDescription { + width: 70% } + + + .SMarked { + background-color: #F8F8D8 } + + .SDescription { padding-left: 2ex } + .SIndent1 .SEntry { padding-left: 1.5ex } .SIndent1 .SDescription { padding-left: 3.5ex } + .SIndent2 .SEntry { padding-left: 3.0ex } .SIndent2 .SDescription { padding-left: 5.0ex } + .SIndent3 .SEntry { padding-left: 4.5ex } .SIndent3 .SDescription { padding-left: 6.5ex } + .SIndent4 .SEntry { padding-left: 6.0ex } .SIndent4 .SDescription { padding-left: 8.0ex } + .SIndent5 .SEntry { padding-left: 7.5ex } .SIndent5 .SDescription { padding-left: 9.5ex } + + .SDescription a { color: #800000} + .SDescription a:active { color: #A00000 } + + .SGroup td { + padding-top: .5em; padding-bottom: .25em } + + .SGroup .SEntry { + font-weight: bold; font-variant: small-caps } + + .SGroup .SEntry a { color: #800000 } + .SGroup .SEntry a:active { color: #F00000 } + + + .SMain td, + .SClass td, + .SDatabase td, + .SDatabaseTable td, + .SSection td { + font-size: 10pt; + padding-bottom: .25em } + + .SClass td, + .SDatabase td, + .SDatabaseTable td, + .SSection td { + padding-top: 1em } + + .SMain .SEntry, + .SClass .SEntry, + .SDatabase .SEntry, + .SDatabaseTable .SEntry, + .SSection .SEntry { + font-weight: bold; + } + + .SMain .SEntry a, + .SClass .SEntry a, + .SDatabase .SEntry a, + .SDatabaseTable .SEntry a, + .SSection .SEntry a { color: #000000 } + + .SMain .SEntry a:active, + .SClass .SEntry a:active, + .SDatabase .SEntry a:active, + .SDatabaseTable .SEntry a:active, + .SSection .SEntry a:active { color: #A00000 } + + + + + +.ClassHierarchy { + margin: 0 15px 1em 15px } + + .CHEntry { + border-width: 1px 2px 2px 1px; border-style: solid; border-color: #A0A0A0; + margin-bottom: 3px; + padding: 2px 2ex; + font-size: 10pt; + background-color: #F4F4F4; color: #606060; + } + + .Firefox .CHEntry { + -moz-border-radius: 4px; + } + + .CHCurrent .CHEntry { + font-weight: bold; + border-color: #000000; + color: #000000; + } + + .CHChildNote .CHEntry { + font-style: italic; + font-size: 8pt; + } + + .CHIndent { + margin-left: 3ex; + } + + .CHEntry a:link, + .CHEntry a:visited, + .CHEntry a:hover { + color: #606060; + } + .CHEntry a:active { + color: #800000; + } + + + + + +#Index { + background-color: #FFFFFF; + } + +/* As opposed to .PopupSearchResultsPage #Index */ +.IndexPage #Index, +.FramedIndexPage #Index, +.FramedSearchResultsPage #Index { + padding: 15px; + } + +.IndexPage #Index { + border-width: 0 0 1px 1px; + border-style: solid; + border-color: #000000; + font-size: 9pt; /* To make 27ex match the menu's 27ex. */ + margin-left: 27ex; + } + + + .IPageTitle { + font-size: 20pt; font-weight: bold; + color: #FFFFFF; background-color: #7070C0; + padding: 10px 15px 10px 15px; + border-width: 0 0 3px 0; border-color: #000000; border-style: solid; + margin: -15px -15px 0 -15px } + + .FramedSearchResultsPage .IPageTitle { + margin-bottom: 15px; + } + + .INavigationBar { + font-size: 10pt; + text-align: center; + background-color: #FFFFF0; + padding: 5px; + border-bottom: solid 1px black; + margin: 0 -15px 15px -15px; + } + + .INavigationBar a { + font-weight: bold } + + .IHeading { + font-size: 16pt; font-weight: bold; + padding: 2.5em 0 .5em 0; + text-align: center; + width: 3.5ex; + } + #IFirstHeading { + padding-top: 0; + } + + .IEntry { + font-size: 10pt; + padding-left: 1ex; + } + .PopupSearchResultsPage .IEntry { + font-size: 8pt; + padding: 1px 5px; + } + .PopupSearchResultsPage .Opera9 .IEntry, + .FramedSearchResultsPage .Opera9 .IEntry { + text-align: left; + } + .FramedSearchResultsPage .IEntry { + padding: 0; + } + + .ISubIndex { + padding-left: 3ex; padding-bottom: .5em } + .PopupSearchResultsPage .ISubIndex { + display: none; + } + + /* While it may cause some entries to look like links when they aren't, I found it's much easier to read the + index if everything's the same color. */ + .ISymbol { + font-weight: bold; color: #900000 } + + .IndexPage .ISymbolPrefix, + .FramedIndexPage .ISymbolPrefix { + font-size: 10pt; + text-align: right; + color: #C47C7C; + background-color: #F8F8F8; + border-right: 3px solid #E0E0E0; + border-left: 1px solid #E0E0E0; + padding: 0 1px 0 2px; + } + .PopupSearchResultsPage .ISymbolPrefix, + .FramedSearchResultsPage .ISymbolPrefix { + color: #900000; + } + .PopupSearchResultsPage .ISymbolPrefix { + font-size: 8pt; + } + + .IndexPage #IFirstSymbolPrefix, + .FramedIndexPage #IFirstSymbolPrefix { + border-top: 1px solid #E0E0E0; + } + .IndexPage #ILastSymbolPrefix, + .FramedIndexPage #ILastSymbolPrefix { + border-bottom: 1px solid #E0E0E0; + } + .IndexPage #IOnlySymbolPrefix, + .FramedIndexPage #IOnlySymbolPrefix { + border-top: 1px solid #E0E0E0; + border-bottom: 1px solid #E0E0E0; + } + + a.IParent, + a.IFile { + display: block; + } + + .PopupSearchResultsPage .SRStatus { + padding: 2px 5px; + font-size: 8pt; + font-style: italic; + } + .FramedSearchResultsPage .SRStatus { + font-size: 10pt; + font-style: italic; + } + + .SRResult { + display: none; + } + + + +#Footer { + font-size: 8pt; + color: #989898; + text-align: right; + } + +#Footer p { + text-indent: 0; + margin-bottom: .5em; + } + +.ContentPage #Footer, +.IndexPage #Footer { + text-align: right; + margin: 2px; + } + +.FramedMenuPage #Footer { + text-align: center; + margin: 5em 10px 10px 10px; + padding-top: 1em; + border-top: 1px solid #C8C8C8; + } + + #Footer a:link, + #Footer a:hover, + #Footer a:visited { color: #989898 } + #Footer a:active { color: #A00000 } + diff --git a/docs/html/styles/2.css b/docs/html/styles/2.css new file mode 100644 index 0000000..69a1d1a --- /dev/null +++ b/docs/html/styles/2.css @@ -0,0 +1,6 @@ +#Menu { + padding: 48px 0 0 0; + background: url(file:../../coremark_logo.jpg) no-repeat; + background-position: 30px 10px; + } + diff --git a/docs/html/styles/main.css b/docs/html/styles/main.css new file mode 100644 index 0000000..a672a94 --- /dev/null +++ b/docs/html/styles/main.css @@ -0,0 +1,2 @@ +@import URL("1.css"); +@import URL("2.css"); diff --git a/linux/core_portme.c b/linux/core_portme.c new file mode 100755 index 0000000..2f07490 --- /dev/null +++ b/linux/core_portme.c @@ -0,0 +1,327 @@ +/* + File: core_portme.c +*/ +/* + Author : Shay Gal-On, EEMBC + Legal : TODO! +*/ +#include +#include +#include "coremark.h" +#if CALLGRIND_RUN +#include +#endif + +#if (MEM_METHOD==MEM_MALLOC) +#include +/* Function: portable_malloc + Provide malloc() functionality in a platform specific way. +*/ +void *portable_malloc(size_t size) { + return malloc(size); +} +/* Function: portable_free + Provide free() functionality in a platform specific way. +*/ +void portable_free(void *p) { + free(p); +} +#else +void *portable_malloc(size_t size) { + return NULL; +} +void portable_free(void *p) { + p=NULL; +} +#endif + +#if (SEED_METHOD==SEED_VOLATILE) +#if VALIDATION_RUN + volatile ee_s32 seed1_volatile=0x3415; + volatile ee_s32 seed2_volatile=0x3415; + volatile ee_s32 seed3_volatile=0x66; +#endif +#if PERFORMANCE_RUN + volatile ee_s32 seed1_volatile=0x0; + volatile ee_s32 seed2_volatile=0x0; + volatile ee_s32 seed3_volatile=0x66; +#endif +#if PROFILE_RUN + volatile ee_s32 seed1_volatile=0x8; + volatile ee_s32 seed2_volatile=0x8; + volatile ee_s32 seed3_volatile=0x8; +#endif + volatile ee_s32 seed4_volatile=ITERATIONS; + volatile ee_s32 seed5_volatile=0; +#endif +/* Porting: Timing functions + How to capture time and convert to seconds must be ported to whatever is supported by the platform. + e.g. Read value from on board RTC, read value from cpu clock cycles performance counter etc. + Sample implementation for standard time.h and windows.h definitions included. +*/ +/* Define: TIMER_RES_DIVIDER + Divider to trade off timer resolution and total time that can be measured. + + Use lower values to increase resolution, but make sure that overflow does not occur. + If there are issues with the return value overflowing, increase this value. + */ +#if USE_CLOCK + #define NSECS_PER_SEC CLOCKS_PER_SEC + #define EE_TIMER_TICKER_RATE 1000 + #define CORETIMETYPE clock_t + #define GETMYTIME(_t) (*_t=clock()) + #define MYTIMEDIFF(fin,ini) ((fin)-(ini)) + #define TIMER_RES_DIVIDER 1 + #define SAMPLE_TIME_IMPLEMENTATION 1 +#elif defined(_MSC_VER) + #define NSECS_PER_SEC 10000000 + #define EE_TIMER_TICKER_RATE 1000 + #define CORETIMETYPE FILETIME + #define GETMYTIME(_t) GetSystemTimeAsFileTime(_t) + #define MYTIMEDIFF(fin,ini) (((*(__int64*)&fin)-(*(__int64*)&ini))/TIMER_RES_DIVIDER) + /* setting to millisces resolution by default with MSDEV */ + #ifndef TIMER_RES_DIVIDER + #define TIMER_RES_DIVIDER 1000 + #endif + #define SAMPLE_TIME_IMPLEMENTATION 1 +#elif HAS_TIME_H + #define NSECS_PER_SEC 1000000000 + #define EE_TIMER_TICKER_RATE 1000 + #define CORETIMETYPE struct timespec + #define GETMYTIME(_t) clock_gettime(CLOCK_REALTIME,_t) + #define MYTIMEDIFF(fin,ini) ((fin.tv_sec-ini.tv_sec)*(NSECS_PER_SEC/TIMER_RES_DIVIDER)+(fin.tv_nsec-ini.tv_nsec)/TIMER_RES_DIVIDER) + /* setting to 1/1000 of a second resolution by default with linux */ + #ifndef TIMER_RES_DIVIDER + #define TIMER_RES_DIVIDER 1000000 + #endif + #define SAMPLE_TIME_IMPLEMENTATION 1 +#else + #define SAMPLE_TIME_IMPLEMENTATION 0 +#endif +#define EE_TICKS_PER_SEC (NSECS_PER_SEC / TIMER_RES_DIVIDER) + +#if SAMPLE_TIME_IMPLEMENTATION +/** Define Host specific (POSIX), or target specific global time variables. */ +static CORETIMETYPE start_time_val, stop_time_val; + +/* Function: start_time + This function will be called right before starting the timed portion of the benchmark. + + Implementation may be capturing a system timer (as implemented in the example code) + or zeroing some system parameters - e.g. setting the cpu clocks cycles to 0. +*/ +void start_time(void) { + GETMYTIME(&start_time_val ); +#if CALLGRIND_RUN + CALLGRIND_START_INSTRUMENTATION +#endif +#if MICA + asm volatile("int3");/*1 */ +#endif +} +/* Function: stop_time + This function will be called right after ending the timed portion of the benchmark. + + Implementation may be capturing a system timer (as implemented in the example code) + or other system parameters - e.g. reading the current value of cpu cycles counter. +*/ +void stop_time(void) { +#if CALLGRIND_RUN + CALLGRIND_STOP_INSTRUMENTATION +#endif +#if MICA + asm volatile("int3");/*1 */ +#endif + GETMYTIME(&stop_time_val ); +} +/* Function: get_time + Return an abstract "ticks" number that signifies time on the system. + + Actual value returned may be cpu cycles, milliseconds or any other value, + as long as it can be converted to seconds by . + This methodology is taken to accomodate any hardware or simulated platform. + The sample implementation returns millisecs by default, + and the resolution is controlled by +*/ +CORE_TICKS get_time(void) { + CORE_TICKS elapsed=(CORE_TICKS)(MYTIMEDIFF(stop_time_val, start_time_val)); + return elapsed; +} +/* Function: time_in_secs + Convert the value returned by get_time to seconds. + + The type is used to accomodate systems with no support for floating point. + Default implementation implemented by the EE_TICKS_PER_SEC macro above. +*/ +secs_ret time_in_secs(CORE_TICKS ticks) { + secs_ret retval=((secs_ret)ticks) / (secs_ret)EE_TICKS_PER_SEC; + return retval; +} +#else +#error "Please implement timing functionality in core_portme.c" +#endif /* SAMPLE_TIME_IMPLEMENTATION */ + +ee_u32 default_num_contexts=MULTITHREAD; + +/* Function: portable_init + Target specific initialization code + Test for some common mistakes. +*/ +void portable_init(core_portable *p, int *argc, char *argv[]) +{ +#if PRINT_ARGS + int i; + for (i=0; i<*argc; i++) { + ee_printf("Arg[%d]=%s\n",i,argv[i]); + } +#endif + if (sizeof(ee_ptr_int) != sizeof(ee_u8 *)) { + ee_printf("ERROR! Please define ee_ptr_int to a type that holds a pointer!\n"); + } + if (sizeof(ee_u32) != 4) { + ee_printf("ERROR! Please define ee_u32 to a 32b unsigned type!\n"); + } +#if (MAIN_HAS_NOARGC && (SEED_METHOD==SEED_ARG)) + ee_printf("ERROR! Main has no argc, but SEED_METHOD defined to SEED_ARG!\n"); +#endif + +#if (MULTITHREAD>1) && (SEED_METHOD==SEED_ARG) + { + int nargs=*argc,i; + if ((nargs>1) && (*argv[1]=='M')) { + default_num_contexts=parseval(argv[1]+1); + if (default_num_contexts>MULTITHREAD) + default_num_contexts=MULTITHREAD; + /* Shift args since first arg is directed to the portable part and not to coremark main */ + --nargs; + for (i=1; i*/ + p->portable_id=1; +} +/* Function: portable_fini + Target specific final code +*/ +void portable_fini(core_portable *p) +{ + p->portable_id=0; +} + +#if (MULTITHREAD>1) + +/* Function: core_start_parallel + Start benchmarking in a parallel context. + + Three implementations are provided, one using pthreads, one using fork and shared mem, and one using fork and sockets. + Other implementations using MCAPI or other standards can easily be devised. +*/ +/* Function: core_stop_parallel + Stop a parallel context execution of coremark, and gather the results. + + Three implementations are provided, one using pthreads, one using fork and shared mem, and one using fork and sockets. + Other implementations using MCAPI or other standards can easily be devised. +*/ +#if USE_PTHREAD +ee_u8 core_start_parallel(core_results *res) { + return (ee_u8)pthread_create(&(res->port.thread),NULL,iterate,(void *)res); +} +ee_u8 core_stop_parallel(core_results *res) { + void *retval; + return (ee_u8)pthread_join(res->port.thread,&retval); +} +#elif USE_FORK +static int key_id=0; +ee_u8 core_start_parallel(core_results *res) { + key_t key=4321+key_id; + key_id++; + res->port.pid=fork(); + res->port.shmid=shmget(key, 8, IPC_CREAT | 0666); + if (res->port.shmid<0) { + ee_printf("ERROR in shmget!\n"); + } + if (res->port.pid==0) { + iterate(res); + res->port.shm=shmat(res->port.shmid, NULL, 0); + /* copy the validation values to the shared memory area and quit*/ + if (res->port.shm == (char *) -1) { + ee_printf("ERROR in child shmat!\n"); + } else { + memcpy(res->port.shm,&(res->crc),8); + shmdt(res->port.shm); + } + exit(0); + } + return 1; +} +ee_u8 core_stop_parallel(core_results *res) { + int status; + pid_t wpid = waitpid(res->port.pid,&status,WUNTRACED); + if (wpid != res->port.pid) { + ee_printf("ERROR waiting for child.\n"); + if (errno == ECHILD) ee_printf("errno=No such child %d\n",res->port.pid); + if (errno == EINTR) ee_printf("errno=Interrupted\n"); + return 0; + } + /* after process is done, get the values from the shared memory area */ + res->port.shm=shmat(res->port.shmid, NULL, 0); + if (res->port.shm == (char *) -1) { + ee_printf("ERROR in parent shmat!\n"); + return 0; + } + memcpy(&(res->crc),res->port.shm,8); + shmdt(res->port.shm); + return 1; +} +#elif USE_SOCKET +static int key_id=0; +ee_u8 core_start_parallel(core_results *res) { + int bound, buffer_length=8; + res->port.sa.sin_family = AF_INET; + res->port.sa.sin_addr.s_addr = htonl(0x7F000001); + res->port.sa.sin_port = htons(7654+key_id); + key_id++; + res->port.pid=fork(); + if (res->port.pid==0) { /* benchmark child */ + iterate(res); + res->port.sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP); + if (-1 == res->port.sock) /* if socket failed to initialize, exit */ { + ee_printf("Error Creating Socket"); + } else { + int bytes_sent = sendto(res->port.sock, &(res->crc), buffer_length, 0,(struct sockaddr*)&(res->port.sa), sizeof (struct sockaddr_in)); + if (bytes_sent < 0) + ee_printf("Error sending packet: %s\n", strerror(errno)); + close(res->port.sock); /* close the socket */ + } + exit(0); + } + /* parent process, open the socket */ + res->port.sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP); + bound = bind(res->port.sock,(struct sockaddr*)&(res->port.sa), sizeof(struct sockaddr)); + if (bound < 0) + ee_printf("bind(): %s\n",strerror(errno)); + return 1; +} +ee_u8 core_stop_parallel(core_results *res) { + int status; + int fromlen=sizeof(struct sockaddr); + int recsize = recvfrom(res->port.sock, &(res->crc), 8, 0, (struct sockaddr*)&(res->port.sa), &fromlen); + if (recsize < 0) { + ee_printf("Error in receive: %s\n", strerror(errno)); + return 0; + } + pid_t wpid = waitpid(res->port.pid,&status,WUNTRACED); + if (wpid != res->port.pid) { + ee_printf("ERROR waiting for child.\n"); + if (errno == ECHILD) ee_printf("errno=No such child %d\n",res->port.pid); + if (errno == EINTR) ee_printf("errno=Interrupted\n"); + return 0; + } + return 1; +} +#else /* no standard multicore implementation */ +#error "Please implement multicore functionality in core_portme.c to use multiple contexts." +#endif /* multithread implementations */ +#endif diff --git a/linux/core_portme.h b/linux/core_portme.h new file mode 100755 index 0000000..a7642bc --- /dev/null +++ b/linux/core_portme.h @@ -0,0 +1,281 @@ +/* File: core_portme.h */ + +/* + Author : Shay Gal-On, EEMBC + Legal : TODO! +*/ +/* Topic: Description + This file contains configuration constants required to execute on different platforms +*/ +#ifndef CORE_PORTME_H +#define CORE_PORTME_H +/************************/ +/* Data types and settings */ +/************************/ +/* Configuration: HAS_FLOAT + Define to 1 if the platform supports floating point. +*/ +#ifndef HAS_FLOAT +#define HAS_FLOAT 1 +#endif +/* Configuration: HAS_TIME_H + Define to 1 if platform has the time.h header file, + and implementation of functions thereof. +*/ +#ifndef HAS_TIME_H +#define HAS_TIME_H 1 +#endif +/* Configuration: USE_CLOCK + Define to 1 if platform has the time.h header file, + and implementation of functions thereof. +*/ +#ifndef USE_CLOCK +#define USE_CLOCK 0 +#endif +/* Configuration: HAS_STDIO + Define to 1 if the platform has stdio.h. +*/ +#ifndef HAS_STDIO +#define HAS_STDIO 1 +#endif +/* Configuration: HAS_PRINTF + Define to 1 if the platform has stdio.h and implements the printf function. +*/ +#ifndef HAS_PRINTF +#define HAS_PRINTF 1 +#endif + +/* Configuration: CORE_TICKS + Define type of return from the timing functions. + */ +#if defined(_MSC_VER) +#include +typedef size_t CORE_TICKS; +#elif HAS_TIME_H +#include +typedef clock_t CORE_TICKS; +#else +#error "Please define type of CORE_TICKS and implement start_time, end_time get_time and time_in_secs functions!" +#endif + +/* Definitions: COMPILER_VERSION, COMPILER_FLAGS, MEM_LOCATION + Initialize these strings per platform +*/ +#ifndef COMPILER_VERSION + #ifdef __GNUC__ + #define COMPILER_VERSION "GCC"__VERSION__ + #else + #define COMPILER_VERSION "Please put compiler version here (e.g. gcc 4.1)" + #endif +#endif +#ifndef COMPILER_FLAGS + #define COMPILER_FLAGS FLAGS_STR /* "Please put compiler flags here (e.g. -o3)" */ +#endif +#ifndef MEM_LOCATION + #define MEM_LOCATION "Please put data memory location here\n\t\t\t(e.g. code in flash, data on heap etc)" + #define MEM_LOCATION_UNSPEC 1 +#endif + +/* Data Types: + To avoid compiler issues, define the data types that need ot be used for 8b, 16b and 32b in . + + *Imprtant*: + ee_ptr_int needs to be the data type used to hold pointers, otherwise coremark may fail!!! +*/ +typedef signed short ee_s16; +typedef unsigned short ee_u16; +typedef signed int ee_s32; +typedef double ee_f32; +typedef unsigned char ee_u8; +typedef unsigned int ee_u32; +typedef ee_u32 ee_ptr_int; +typedef size_t ee_size_t; +/* align_mem: + This macro is used to align an offset to point to a 32b value. It is used in the Matrix algorithm to initialize the input memory blocks. +*/ +#define align_mem(x) (void *)(4 + (((ee_ptr_int)(x) - 1) & ~3)) + +/* Configuration: SEED_METHOD + Defines method to get seed values that cannot be computed at compile time. + + Valid values: + SEED_ARG - from command line. + SEED_FUNC - from a system function. + SEED_VOLATILE - from volatile variables. +*/ +#ifndef SEED_METHOD +#define SEED_METHOD SEED_ARG +#endif + +/* Configuration: MEM_METHOD + Defines method to get a block of memry. + + Valid values: + MEM_MALLOC - for platforms that implement malloc and have malloc.h. + MEM_STATIC - to use a static memory array. + MEM_STACK - to allocate the data block on the stack (NYI). +*/ +#ifndef MEM_METHOD +#define MEM_METHOD MEM_MALLOC +#endif + +/* Configuration: MULTITHREAD + Define for parallel execution + + Valid values: + 1 - only one context (default). + N>1 - will execute N copies in parallel. + + Note: + If this flag is defined to more then 1, an implementation for launching parallel contexts must be defined. + + Two sample implementations are provided. Use or to enable them. + + It is valid to have a different implementation of and in , + to fit a particular architecture. +*/ +#ifndef MULTITHREAD +#define MULTITHREAD 1 +#endif + +/* Configuration: USE_PTHREAD + Sample implementation for launching parallel contexts + This implementation uses pthread_thread_create and pthread_join. + + Valid values: + 0 - Do not use pthreads API. + 1 - Use pthreads API + + Note: + This flag only matters if MULTITHREAD has been defined to a value greater then 1. +*/ +#ifndef USE_PTHREAD +#define USE_PTHREAD 0 +#endif + +/* Configuration: USE_FORK + Sample implementation for launching parallel contexts + This implementation uses fork, waitpid, shmget,shmat and shmdt. + + Valid values: + 0 - Do not use fork API. + 1 - Use fork API + + Note: + This flag only matters if MULTITHREAD has been defined to a value greater then 1. +*/ +#ifndef USE_FORK +#define USE_FORK 0 +#endif + +/* Configuration: USE_SOCKET + Sample implementation for launching parallel contexts + This implementation uses fork, socket, sendto and recvfrom + + Valid values: + 0 - Do not use fork and sockets API. + 1 - Use fork and sockets API + + Note: + This flag only matters if MULTITHREAD has been defined to a value greater then 1. +*/ +#ifndef USE_SOCKET +#define USE_SOCKET 0 +#endif + +/* Configuration: MAIN_HAS_NOARGC + Needed if platform does not support getting arguments to main. + + Valid values: + 0 - argc/argv to main is supported + 1 - argc/argv to main is not supported +*/ +#ifndef MAIN_HAS_NOARGC +#define MAIN_HAS_NOARGC 0 +#endif + +/* Configuration: MAIN_HAS_NORETURN + Needed if platform does not support returning a value from main. + + Valid values: + 0 - main returns an int, and return value will be 0. + 1 - platform does not support returning a value from main +*/ +#ifndef MAIN_HAS_NORETURN +#define MAIN_HAS_NORETURN 0 +#endif + +/* Variable: default_num_contexts + Number of contexts to spawn in multicore context. + Override this global value to change number of contexts used. + + Note: + This value may not be set higher then the define. + + To experiment, you can set the define to the highest value expected, and use argc/argv in the to set this value from the command line. +*/ +extern ee_u32 default_num_contexts; + +#if (MULTITHREAD>1) +#if USE_PTHREAD + #include + #define PARALLEL_METHOD "PThreads" +#elif USE_FORK + #include + #include + #include + #include + #include /* for memcpy */ + #define PARALLEL_METHOD "Fork" +#elif USE_SOCKET + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #define PARALLEL_METHOD "Sockets" +#else + #define PARALLEL_METHOD "Proprietary" + #error "Please implement multicore functionality in core_portme.c to use multiple contexts." +#endif /* Method for multithreading */ +#endif /* MULTITHREAD > 1 */ + +typedef struct CORE_PORTABLE_S { +#if (MULTITHREAD>1) + #if USE_PTHREAD + pthread_t thread; + #elif USE_FORK + pid_t pid; + int shmid; + void *shm; + #elif USE_SOCKET + pid_t pid; + int sock; + struct sockaddr_in sa; + #endif /* Method for multithreading */ +#endif /* MULTITHREAD>1 */ + ee_u8 portable_id; +} core_portable; + +/* target specific init/fini */ +void portable_init(core_portable *p, int *argc, char *argv[]); +void portable_fini(core_portable *p); + +#if (SEED_METHOD==SEED_VOLATILE) + #if (VALIDATION_RUN || PERFORMANCE_RUN || PROFILE_RUN) + #define RUN_TYPE_FLAG 1 + #else + #if (TOTAL_DATA_SIZE==1200) + #define PROFILE_RUN 1 + #else + #define PERFORMANCE_RUN 1 + #endif + #endif +#endif /* SEED_METHOD==SEED_VOLATILE */ + +#endif /* CORE_PORTME_H */ diff --git a/linux/core_portme.mak b/linux/core_portme.mak new file mode 100755 index 0000000..025b035 --- /dev/null +++ b/linux/core_portme.mak @@ -0,0 +1,124 @@ +#File: core_portme.mak + +# Flag: OUTFLAG +# Use this flag to define how to to get an executable (e.g -o) +OUTFLAG= -o +# Flag: CC +# Use this flag to define compiler to use +CC = gcc +# Flag: CFLAGS +# Use this flag to define compiler options. Note, you can add compiler options from the command line using XCFLAGS="other flags" +PORT_CFLAGS = -O2 +FLAGS_STR = "$(PORT_CFLAGS) $(XCFLAGS) $(XLFLAGS) $(LFLAGS_END)" +CFLAGS = $(PORT_CFLAGS) -I$(PORT_DIR) -I. -DFLAGS_STR=\"$(FLAGS_STR)\" +#Flag: LFLAGS_END +# Define any libraries needed for linking or other flags that should come at the end of the link line (e.g. linker scripts). +# Note: On certain platforms, the default clock_gettime implementation is supported but requires linking of librt. +LFLAGS_END += -lrt +# Flag: PORT_SRCS +# Port specific source files can be added here +PORT_SRCS = $(PORT_DIR)/core_portme.c +# Flag: LOAD +# Define this flag if you need to load to a target, as in a cross compile environment. + +# Flag: RUN +# Define this flag if running does not consist of simple invocation of the binary. +# In a cross compile environment, you need to define this. + +#For flashing and using a tera term macro, you could use +#LOAD = flash ADDR +#RUN = ttpmacro coremark.ttl + +#For copying to target and executing via SSH connection, you could use +#LOAD = scp $(OUTFILE) user@target:~ +#RUN = ssh user@target -c + +#For native compilation and execution +LOAD = echo Loading done +RUN = + +OEXT = .o +EXE = .exe + +# Flag: SEPARATE_COMPILE +# Define if you need to separate compilation from link stage. +# In this case, you also need to define below how to create an object file, and how to link. +ifdef SEPARATE_COMPILE + +LD = gcc +OBJOUT = -o +LFLAGS = +OFLAG = -o +COUT = -c +# Flag: PORT_OBJS +# Port specific object files can be added here +PORT_OBJS = $(PORT_DIR)/core_portme$(OEXT) +PORT_CLEAN = *$(OEXT) + +$(OPATH)%$(OEXT) : %.c + $(CC) $(CFLAGS) $(XCFLAGS) $(COUT) $< $(OBJOUT) $@ + +endif + +# Target: port_prebuild +# Generate any files that are needed before actual build starts. +# E.g. generate profile guidance files. Sample PGO generation for gcc enabled with PGO=1 +# - First, check if PGO was defined on the command line, if so, need to add -fprofile-use to compile line. +# - Second, if PGO reference has not yet been generated, add a step to the prebuild that will build a profile-generate version and run it. +# Note - Using REBUILD=1 +# +# Use make PGO=1 to invoke this sample processing. + +ifdef PGO + ifeq (,$(findstring $(PGO),gen)) + PGO_STAGE=build_pgo_gcc + CFLAGS+=-fprofile-use + endif + PORT_CLEAN+=*.gcda *.gcno gmon.out +endif + +.PHONY: port_prebuild +port_prebuild: $(PGO_STAGE) + +.PHONY: build_pgo_gcc +build_pgo_gcc: + $(MAKE) PGO=gen XCFLAGS="$(XCFLAGS) -fprofile-generate -DTOTAL_DATA_SIZE=1200" ITERATIONS=10 gen_pgo_data REBUILD=1 + +# Target: port_postbuild +# Generate any files that are needed after actual build end. +# E.g. change format to srec, bin, zip in order to be able to load into flash +.PHONY: port_postbuild +port_postbuild: + +# Target: port_postrun +# Do platform specific after run stuff. +# E.g. reset the board, backup the logfiles etc. +.PHONY: port_postrun +port_postrun: + +# Target: port_prerun +# Do platform specific after run stuff. +# E.g. reset the board, backup the logfiles etc. +.PHONY: port_prerun +port_prerun: + +# Target: port_postload +# Do platform specific after load stuff. +# E.g. reset the reset power to the flash eraser +.PHONY: port_postload +port_postload: + +# Target: port_preload +# Do platform specific before load stuff. +# E.g. reset the reset power to the flash eraser +.PHONY: port_preload +port_preload: + +# FLAG: OPATH +# Path to the output folder. Default - current folder. +OPATH = ./ +MKDIR = mkdir -p + +# FLAG: PERL +# Define perl executable to calculate the geomean if running separate. +PERL=/usr/bin/perl diff --git a/linux64/core_portme.c b/linux64/core_portme.c new file mode 100755 index 0000000..10e8f40 --- /dev/null +++ b/linux64/core_portme.c @@ -0,0 +1,325 @@ +/* + File: core_portme.c +*/ +/* + Author : Shay Gal-On, EEMBC + Legal : TODO! +*/ +#include +#include +#include "coremark.h" +#if CALLGRIND_RUN +#include +#endif + +#if (MEM_METHOD==MEM_MALLOC) +#include +/* Function: portable_malloc + Provide malloc() functionality in a platform specific way. +*/ +void *portable_malloc(size_t size) { + return malloc(size); +} +/* Function: portable_free + Provide free() functionality in a platform specific way. +*/ +void portable_free(void *p) { + free(p); +} +#else +void *portable_malloc(size_t size) { + return NULL; +} +void portable_free(void *p) { + p=NULL; +} +#endif + +#if (SEED_METHOD==SEED_VOLATILE) +#if VALIDATION_RUN + volatile ee_s32 seed1_volatile=0x3415; + volatile ee_s32 seed2_volatile=0x3415; + volatile ee_s32 seed3_volatile=0x66; +#endif +#if PERFORMANCE_RUN + volatile ee_s32 seed1_volatile=0x0; + volatile ee_s32 seed2_volatile=0x0; + volatile ee_s32 seed3_volatile=0x66; +#endif +#if PROFILE_RUN + volatile ee_s32 seed1_volatile=0x8; + volatile ee_s32 seed2_volatile=0x8; + volatile ee_s32 seed3_volatile=0x8; +#endif + volatile ee_s32 seed4_volatile=ITERATIONS; + volatile ee_s32 seed5_volatile=0; +#endif +/* Porting: Timing functions + How to capture time and convert to seconds must be ported to whatever is supported by the platform. + e.g. Read value from on board RTC, read value from cpu clock cycles performance counter etc. + Sample implementation for standard time.h and windows.h definitions included. +*/ +/* Define: TIMER_RES_DIVIDER + Divider to trade off timer resolution and total time that can be measured. + + Use lower values to increase resolution, but make sure that overflow does not occur. + If there are issues with the return value overflowing, increase this value. + */ +#if USE_CLOCK + #define NSECS_PER_SEC CLOCKS_PER_SEC + #define EE_TIMER_TICKER_RATE 1000 + #define CORETIMETYPE clock_t + #define GETMYTIME(_t) (*_t=clock()) + #define MYTIMEDIFF(fin,ini) ((fin)-(ini)) + #define TIMER_RES_DIVIDER 1 + #define SAMPLE_TIME_IMPLEMENTATION 1 +#elif defined(_MSC_VER) + #define NSECS_PER_SEC 10000000 + #define EE_TIMER_TICKER_RATE 1000 + #define CORETIMETYPE FILETIME + #define GETMYTIME(_t) GetSystemTimeAsFileTime(_t) + #define MYTIMEDIFF(fin,ini) (((*(__int64*)&fin)-(*(__int64*)&ini))/TIMER_RES_DIVIDER) + /* setting to millisces resolution by default with MSDEV */ + #ifndef TIMER_RES_DIVIDER + #define TIMER_RES_DIVIDER 1000 + #endif + #define SAMPLE_TIME_IMPLEMENTATION 1 +#elif HAS_TIME_H + #define NSECS_PER_SEC 1000000000 + #define EE_TIMER_TICKER_RATE 1000 + #define CORETIMETYPE struct timespec + #define GETMYTIME(_t) clock_gettime(CLOCK_REALTIME,_t) + #define MYTIMEDIFF(fin,ini) ((fin.tv_sec-ini.tv_sec)*(NSECS_PER_SEC/TIMER_RES_DIVIDER)+(fin.tv_nsec-ini.tv_nsec)/TIMER_RES_DIVIDER) + /* setting to 1/1000 of a second resolution by default with linux */ + #ifndef TIMER_RES_DIVIDER + #define TIMER_RES_DIVIDER 1000000 + #endif + #define SAMPLE_TIME_IMPLEMENTATION 1 +#else + #define SAMPLE_TIME_IMPLEMENTATION 0 +#endif +#define EE_TICKS_PER_SEC (NSECS_PER_SEC / TIMER_RES_DIVIDER) + +#if SAMPLE_TIME_IMPLEMENTATION +/** Define Host specific (POSIX), or target specific global time variables. */ +static CORETIMETYPE start_time_val, stop_time_val; + +/* Function: start_time + This function will be called right before starting the timed portion of the benchmark. + + Implementation may be capturing a system timer (as implemented in the example code) + or zeroing some system parameters - e.g. setting the cpu clocks cycles to 0. +*/ +void start_time(void) { + GETMYTIME(&start_time_val ); +#if CALLGRIND_RUN + CALLGRIND_START_INSTRUMENTATION +#endif +#if MICA + asm volatile("int3");/*1 */ +#endif +} +/* Function: stop_time + This function will be called right after ending the timed portion of the benchmark. + + Implementation may be capturing a system timer (as implemented in the example code) + or other system parameters - e.g. reading the current value of cpu cycles counter. +*/ +void stop_time(void) { +#if CALLGRIND_RUN + CALLGRIND_STOP_INSTRUMENTATION +#endif +#if MICA + asm volatile("int3");/*1 */ +#endif + GETMYTIME(&stop_time_val ); +} +/* Function: get_time + Return an abstract "ticks" number that signifies time on the system. + + Actual value returned may be cpu cycles, milliseconds or any other value, + as long as it can be converted to seconds by . + This methodology is taken to accomodate any hardware or simulated platform. + The sample implementation returns millisecs by default, + and the resolution is controlled by +*/ +CORE_TICKS get_time(void) { + CORE_TICKS elapsed=(CORE_TICKS)(MYTIMEDIFF(stop_time_val, start_time_val)); + return elapsed; +} +/* Function: time_in_secs + Convert the value returned by get_time to seconds. + + The type is used to accomodate systems with no support for floating point. + Default implementation implemented by the EE_TICKS_PER_SEC macro above. +*/ +secs_ret time_in_secs(CORE_TICKS ticks) { + secs_ret retval=((secs_ret)ticks) / (secs_ret)EE_TICKS_PER_SEC; + return retval; +} +#else +#error "Please implement timing functionality in core_portme.c" +#endif /* SAMPLE_TIME_IMPLEMENTATION */ + +ee_u32 default_num_contexts=MULTITHREAD; + +/* Function: portable_init + Target specific initialization code + Test for some common mistakes. +*/ +void portable_init(core_portable *p, int *argc, char *argv[]) +{ +#if PRINT_ARGS + int i; + for (i=0; i<*argc; i++) { + ee_printf("Arg[%d]=%s\n",i,argv[i]); + } +#endif + if (sizeof(ee_ptr_int) != sizeof(ee_u8 *)) { + ee_printf("ERROR! Please define ee_ptr_int to a type that holds a pointer!\n"); + } + if (sizeof(ee_u32) != 4) { + ee_printf("ERROR! Please define ee_u32 to a 32b unsigned type!\n"); + } +#if (MAIN_HAS_NOARGC && (SEED_METHOD==SEED_ARG)) + ee_printf("ERROR! Main has no argc, but SEED_METHOD defined to SEED_ARG!\n"); +#endif + +#if (MULTITHREAD>1) && (SEED_METHOD==SEED_ARG) + int nargs=*argc,i; + if ((nargs>1) && (*argv[1]=='M')) { + default_num_contexts=parseval(argv[1]+1); + if (default_num_contexts>MULTITHREAD) + default_num_contexts=MULTITHREAD; + /* Shift args since first arg is directed to the portable part and not to coremark main */ + --nargs; + for (i=1; i*/ + p->portable_id=1; +} +/* Function: portable_fini + Target specific final code +*/ +void portable_fini(core_portable *p) +{ + p->portable_id=0; +} + +#if (MULTITHREAD>1) + +/* Function: core_start_parallel + Start benchmarking in a parallel context. + + Three implementations are provided, one using pthreads, one using fork and shared mem, and one using fork and sockets. + Other implementations using MCAPI or other standards can easily be devised. +*/ +/* Function: core_stop_parallel + Stop a parallel context execution of coremark, and gather the results. + + Three implementations are provided, one using pthreads, one using fork and shared mem, and one using fork and sockets. + Other implementations using MCAPI or other standards can easily be devised. +*/ +#if USE_PTHREAD +ee_u8 core_start_parallel(core_results *res) { + return (ee_u8)pthread_create(&(res->port.thread),NULL,iterate,(void *)res); +} +ee_u8 core_stop_parallel(core_results *res) { + void *retval; + return (ee_u8)pthread_join(res->port.thread,&retval); +} +#elif USE_FORK +static int key_id=0; +ee_u8 core_start_parallel(core_results *res) { + key_t key=4321+key_id; + key_id++; + res->port.pid=fork(); + res->port.shmid=shmget(key, 8, IPC_CREAT | 0666); + if (res->port.shmid<0) { + ee_printf("ERROR in shmget!\n"); + } + if (res->port.pid==0) { + iterate(res); + res->port.shm=shmat(res->port.shmid, NULL, 0); + /* copy the validation values to the shared memory area and quit*/ + if (res->port.shm == (char *) -1) { + ee_printf("ERROR in child shmat!\n"); + } else { + memcpy(res->port.shm,&(res->crc),8); + shmdt(res->port.shm); + } + exit(0); + } + return 1; +} +ee_u8 core_stop_parallel(core_results *res) { + int status; + pid_t wpid = waitpid(res->port.pid,&status,WUNTRACED); + if (wpid != res->port.pid) { + ee_printf("ERROR waiting for child.\n"); + if (errno == ECHILD) ee_printf("errno=No such child %d\n",res->port.pid); + if (errno == EINTR) ee_printf("errno=Interrupted\n"); + return 0; + } + /* after process is done, get the values from the shared memory area */ + res->port.shm=shmat(res->port.shmid, NULL, 0); + if (res->port.shm == (char *) -1) { + ee_printf("ERROR in parent shmat!\n"); + return 0; + } + memcpy(&(res->crc),res->port.shm,8); + shmdt(res->port.shm); + return 1; +} +#elif USE_SOCKET +static int key_id=0; +ee_u8 core_start_parallel(core_results *res) { + int bound, buffer_length=8; + res->port.sa.sin_family = AF_INET; + res->port.sa.sin_addr.s_addr = htonl(0x7F000001); + res->port.sa.sin_port = htons(7654+key_id); + key_id++; + res->port.pid=fork(); + if (res->port.pid==0) { /* benchmark child */ + iterate(res); + res->port.sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP); + if (-1 == res->port.sock) /* if socket failed to initialize, exit */ { + ee_printf("Error Creating Socket"); + } else { + int bytes_sent = sendto(res->port.sock, &(res->crc), buffer_length, 0,(struct sockaddr*)&(res->port.sa), sizeof (struct sockaddr_in)); + if (bytes_sent < 0) + ee_printf("Error sending packet: %s\n", strerror(errno)); + close(res->port.sock); /* close the socket */ + } + exit(0); + } + /* parent process, open the socket */ + res->port.sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP); + bound = bind(res->port.sock,(struct sockaddr*)&(res->port.sa), sizeof(struct sockaddr)); + if (bound < 0) + ee_printf("bind(): %s\n",strerror(errno)); + return 1; +} +ee_u8 core_stop_parallel(core_results *res) { + int status; + int fromlen=sizeof(struct sockaddr); + int recsize = recvfrom(res->port.sock, &(res->crc), 8, 0, (struct sockaddr*)&(res->port.sa), &fromlen); + if (recsize < 0) { + ee_printf("Error in receive: %s\n", strerror(errno)); + return 0; + } + pid_t wpid = waitpid(res->port.pid,&status,WUNTRACED); + if (wpid != res->port.pid) { + ee_printf("ERROR waiting for child.\n"); + if (errno == ECHILD) ee_printf("errno=No such child %d\n",res->port.pid); + if (errno == EINTR) ee_printf("errno=Interrupted\n"); + return 0; + } + return 1; +} +#else /* no standard multicore implementation */ +#error "Please implement multicore functionality in core_portme.c to use multiple contexts." +#endif /* multithread implementations */ +#endif diff --git a/linux64/core_portme.h b/linux64/core_portme.h new file mode 100755 index 0000000..a878bc9 --- /dev/null +++ b/linux64/core_portme.h @@ -0,0 +1,279 @@ +/* File: core_portme.h */ + +/* + Author : Shay Gal-On, EEMBC + Legal : TODO! +*/ +/* Topic: Description + This file contains configuration constants required to execute on different platforms +*/ +#ifndef CORE_PORTME_H +#define CORE_PORTME_H +/************************/ +/* Data types and settings */ +/************************/ +/* Configuration: HAS_FLOAT + Define to 1 if the platform supports floating point. +*/ +#ifndef HAS_FLOAT +#define HAS_FLOAT 1 +#endif +/* Configuration: HAS_TIME_H + Define to 1 if platform has the time.h header file, + and implementation of functions thereof. +*/ +#ifndef HAS_TIME_H +#define HAS_TIME_H 1 +#endif +/* Configuration: USE_CLOCK + Define to 1 if platform has the time.h header file, + and implementation of functions thereof. +*/ +#ifndef USE_CLOCK +#define USE_CLOCK 0 +#endif +/* Configuration: HAS_STDIO + Define to 1 if the platform has stdio.h. +*/ +#ifndef HAS_STDIO +#define HAS_STDIO 1 +#endif +/* Configuration: HAS_PRINTF + Define to 1 if the platform has stdio.h and implements the printf function. +*/ +#ifndef HAS_PRINTF +#define HAS_PRINTF 1 +#endif + +/* Configuration: CORE_TICKS + Define type of return from the timing functions. + */ +#if defined(_MSC_VER) +#include +typedef size_t CORE_TICKS; +#elif HAS_TIME_H +#include +typedef clock_t CORE_TICKS; +#else +#error "Please define type of CORE_TICKS and implement start_time, end_time get_time and time_in_secs functions!" +#endif + +/* Definitions: COMPILER_VERSION, COMPILER_FLAGS, MEM_LOCATION + Initialize these strings per platform +*/ +#ifndef COMPILER_VERSION + #ifdef __GNUC__ + #define COMPILER_VERSION "GCC"__VERSION__ + #else + #define COMPILER_VERSION "Please put compiler version here (e.g. gcc 4.1)" + #endif +#endif +#ifndef COMPILER_FLAGS + #define COMPILER_FLAGS FLAGS_STR /* "Please put compiler flags here (e.g. -o3)" */ +#endif +#ifndef MEM_LOCATION + #define MEM_LOCATION "Please put data memory location here\n\t\t\t(e.g. code in flash, data on heap etc)" + #define MEM_LOCATION_UNSPEC 1 +#endif + +/* Data Types: + To avoid compiler issues, define the data types that need ot be used for 8b, 16b and 32b in . + + *Imprtant*: + ee_ptr_int needs to be the data type used to hold pointers, otherwise coremark may fail!!! +*/ +typedef signed short ee_s16; +typedef unsigned short ee_u16; +typedef signed int ee_s32; +typedef double ee_f32; +typedef unsigned char ee_u8; +typedef unsigned int ee_u32; +typedef unsigned long long ee_ptr_int; +typedef size_t ee_size_t; +/* align an offset to point to a 32b value */ +#define align_mem(x) (void *)(4 + (((ee_ptr_int)(x) - 1) & ~3)) + +/* Configuration: SEED_METHOD + Defines method to get seed values that cannot be computed at compile time. + + Valid values: + SEED_ARG - from command line. + SEED_FUNC - from a system function. + SEED_VOLATILE - from volatile variables. +*/ +#ifndef SEED_METHOD +#define SEED_METHOD SEED_ARG +#endif + +/* Configuration: MEM_METHOD + Defines method to get a block of memry. + + Valid values: + MEM_MALLOC - for platforms that implement malloc and have malloc.h. + MEM_STATIC - to use a static memory array. + MEM_STACK - to allocate the data block on the stack (NYI). +*/ +#ifndef MEM_METHOD +#define MEM_METHOD MEM_MALLOC +#endif + +/* Configuration: MULTITHREAD + Define for parallel execution + + Valid values: + 1 - only one context (default). + N>1 - will execute N copies in parallel. + + Note: + If this flag is defined to more then 1, an implementation for launching parallel contexts must be defined. + + Two sample implementations are provided. Use or to enable them. + + It is valid to have a different implementation of and in , + to fit a particular architecture. +*/ +#ifndef MULTITHREAD +#define MULTITHREAD 1 +#endif + +/* Configuration: USE_PTHREAD + Sample implementation for launching parallel contexts + This implementation uses pthread_thread_create and pthread_join. + + Valid values: + 0 - Do not use pthreads API. + 1 - Use pthreads API + + Note: + This flag only matters if MULTITHREAD has been defined to a value greater then 1. +*/ +#ifndef USE_PTHREAD +#define USE_PTHREAD 0 +#endif + +/* Configuration: USE_FORK + Sample implementation for launching parallel contexts + This implementation uses fork, waitpid, shmget,shmat and shmdt. + + Valid values: + 0 - Do not use fork API. + 1 - Use fork API + + Note: + This flag only matters if MULTITHREAD has been defined to a value greater then 1. +*/ +#ifndef USE_FORK +#define USE_FORK 0 +#endif + +/* Configuration: USE_SOCKET + Sample implementation for launching parallel contexts + This implementation uses fork, socket, sendto and recvfrom + + Valid values: + 0 - Do not use fork and sockets API. + 1 - Use fork and sockets API + + Note: + This flag only matters if MULTITHREAD has been defined to a value greater then 1. +*/ +#ifndef USE_SOCKET +#define USE_SOCKET 0 +#endif + +/* Configuration: MAIN_HAS_NOARGC + Needed if platform does not support getting arguments to main. + + Valid values: + 0 - argc/argv to main is supported + 1 - argc/argv to main is not supported +*/ +#ifndef MAIN_HAS_NOARGC +#define MAIN_HAS_NOARGC 0 +#endif + +/* Configuration: MAIN_HAS_NORETURN + Needed if platform does not support returning a value from main. + + Valid values: + 0 - main returns an int, and return value will be 0. + 1 - platform does not support returning a value from main +*/ +#ifndef MAIN_HAS_NORETURN +#define MAIN_HAS_NORETURN 0 +#endif + +/* Variable: default_num_contexts + Number of contexts to spawn in multicore context. + Override this global value to change number of contexts used. + + Note: + This value may not be set higher then the define. + + To experiment, you can set the define to the highest value expected, and use argc/argv in the to set this value from the command line. +*/ +extern ee_u32 default_num_contexts; + +#if (MULTITHREAD>1) +#if USE_PTHREAD + #include + #define PARALLEL_METHOD "PThreads" +#elif USE_FORK + #include + #include + #include + #include + #include /* for memcpy */ + #define PARALLEL_METHOD "Fork" +#elif USE_SOCKET + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #define PARALLEL_METHOD "Sockets" +#else + #define PARALLEL_METHOD "Proprietary" + #error "Please implement multicore functionality in core_portme.c to use multiple contexts." +#endif /* Method for multithreading */ +#endif /* MULTITHREAD > 1 */ + +typedef struct CORE_PORTABLE_S { +#if (MULTITHREAD>1) + #if USE_PTHREAD + pthread_t thread; + #elif USE_FORK + pid_t pid; + int shmid; + void *shm; + #elif USE_SOCKET + pid_t pid; + int sock; + struct sockaddr_in sa; + #endif /* Method for multithreading */ +#endif /* MULTITHREAD>1 */ + ee_u8 portable_id; +} core_portable; + +/* target specific init/fini */ +void portable_init(core_portable *p, int *argc, char *argv[]); +void portable_fini(core_portable *p); + +#if (SEED_METHOD==SEED_VOLATILE) + #if (VALIDATION_RUN || PERFORMANCE_RUN || PROFILE_RUN) + #define RUN_TYPE_FLAG 1 + #else + #if (TOTAL_DATA_SIZE==1200) + #define PROFILE_RUN 1 + #else + #define PERFORMANCE_RUN 1 + #endif + #endif +#endif /* SEED_METHOD==SEED_VOLATILE */ + +#endif /* CORE_PORTME_H */ diff --git a/linux64/core_portme.mak b/linux64/core_portme.mak new file mode 100755 index 0000000..025b035 --- /dev/null +++ b/linux64/core_portme.mak @@ -0,0 +1,124 @@ +#File: core_portme.mak + +# Flag: OUTFLAG +# Use this flag to define how to to get an executable (e.g -o) +OUTFLAG= -o +# Flag: CC +# Use this flag to define compiler to use +CC = gcc +# Flag: CFLAGS +# Use this flag to define compiler options. Note, you can add compiler options from the command line using XCFLAGS="other flags" +PORT_CFLAGS = -O2 +FLAGS_STR = "$(PORT_CFLAGS) $(XCFLAGS) $(XLFLAGS) $(LFLAGS_END)" +CFLAGS = $(PORT_CFLAGS) -I$(PORT_DIR) -I. -DFLAGS_STR=\"$(FLAGS_STR)\" +#Flag: LFLAGS_END +# Define any libraries needed for linking or other flags that should come at the end of the link line (e.g. linker scripts). +# Note: On certain platforms, the default clock_gettime implementation is supported but requires linking of librt. +LFLAGS_END += -lrt +# Flag: PORT_SRCS +# Port specific source files can be added here +PORT_SRCS = $(PORT_DIR)/core_portme.c +# Flag: LOAD +# Define this flag if you need to load to a target, as in a cross compile environment. + +# Flag: RUN +# Define this flag if running does not consist of simple invocation of the binary. +# In a cross compile environment, you need to define this. + +#For flashing and using a tera term macro, you could use +#LOAD = flash ADDR +#RUN = ttpmacro coremark.ttl + +#For copying to target and executing via SSH connection, you could use +#LOAD = scp $(OUTFILE) user@target:~ +#RUN = ssh user@target -c + +#For native compilation and execution +LOAD = echo Loading done +RUN = + +OEXT = .o +EXE = .exe + +# Flag: SEPARATE_COMPILE +# Define if you need to separate compilation from link stage. +# In this case, you also need to define below how to create an object file, and how to link. +ifdef SEPARATE_COMPILE + +LD = gcc +OBJOUT = -o +LFLAGS = +OFLAG = -o +COUT = -c +# Flag: PORT_OBJS +# Port specific object files can be added here +PORT_OBJS = $(PORT_DIR)/core_portme$(OEXT) +PORT_CLEAN = *$(OEXT) + +$(OPATH)%$(OEXT) : %.c + $(CC) $(CFLAGS) $(XCFLAGS) $(COUT) $< $(OBJOUT) $@ + +endif + +# Target: port_prebuild +# Generate any files that are needed before actual build starts. +# E.g. generate profile guidance files. Sample PGO generation for gcc enabled with PGO=1 +# - First, check if PGO was defined on the command line, if so, need to add -fprofile-use to compile line. +# - Second, if PGO reference has not yet been generated, add a step to the prebuild that will build a profile-generate version and run it. +# Note - Using REBUILD=1 +# +# Use make PGO=1 to invoke this sample processing. + +ifdef PGO + ifeq (,$(findstring $(PGO),gen)) + PGO_STAGE=build_pgo_gcc + CFLAGS+=-fprofile-use + endif + PORT_CLEAN+=*.gcda *.gcno gmon.out +endif + +.PHONY: port_prebuild +port_prebuild: $(PGO_STAGE) + +.PHONY: build_pgo_gcc +build_pgo_gcc: + $(MAKE) PGO=gen XCFLAGS="$(XCFLAGS) -fprofile-generate -DTOTAL_DATA_SIZE=1200" ITERATIONS=10 gen_pgo_data REBUILD=1 + +# Target: port_postbuild +# Generate any files that are needed after actual build end. +# E.g. change format to srec, bin, zip in order to be able to load into flash +.PHONY: port_postbuild +port_postbuild: + +# Target: port_postrun +# Do platform specific after run stuff. +# E.g. reset the board, backup the logfiles etc. +.PHONY: port_postrun +port_postrun: + +# Target: port_prerun +# Do platform specific after run stuff. +# E.g. reset the board, backup the logfiles etc. +.PHONY: port_prerun +port_prerun: + +# Target: port_postload +# Do platform specific after load stuff. +# E.g. reset the reset power to the flash eraser +.PHONY: port_postload +port_postload: + +# Target: port_preload +# Do platform specific before load stuff. +# E.g. reset the reset power to the flash eraser +.PHONY: port_preload +port_preload: + +# FLAG: OPATH +# Path to the output folder. Default - current folder. +OPATH = ./ +MKDIR = mkdir -p + +# FLAG: PERL +# Define perl executable to calculate the geomean if running separate. +PERL=/usr/bin/perl diff --git a/simple/core_portme.c b/simple/core_portme.c new file mode 100755 index 0000000..39e0cb8 --- /dev/null +++ b/simple/core_portme.c @@ -0,0 +1,117 @@ +/* + File : core_portme.c +*/ +/* + Author : Shay Gal-On, EEMBC + Legal : TODO! +*/ +#include +#include +#include "coremark.h" + +#if VALIDATION_RUN + volatile ee_s32 seed1_volatile=0x3415; + volatile ee_s32 seed2_volatile=0x3415; + volatile ee_s32 seed3_volatile=0x66; +#endif +#if PERFORMANCE_RUN + volatile ee_s32 seed1_volatile=0x0; + volatile ee_s32 seed2_volatile=0x0; + volatile ee_s32 seed3_volatile=0x66; +#endif +#if PROFILE_RUN + volatile ee_s32 seed1_volatile=0x8; + volatile ee_s32 seed2_volatile=0x8; + volatile ee_s32 seed3_volatile=0x8; +#endif + volatile ee_s32 seed4_volatile=ITERATIONS; + volatile ee_s32 seed5_volatile=0; +/* Porting : Timing functions + How to capture time and convert to seconds must be ported to whatever is supported by the platform. + e.g. Read value from on board RTC, read value from cpu clock cycles performance counter etc. + Sample implementation for standard time.h and windows.h definitions included. +*/ +/* Define : TIMER_RES_DIVIDER + Divider to trade off timer resolution and total time that can be measured. + + Use lower values to increase resolution, but make sure that overflow does not occur. + If there are issues with the return value overflowing, increase this value. + */ +#define NSECS_PER_SEC CLOCKS_PER_SEC +#define CORETIMETYPE clock_t +#define GETMYTIME(_t) (*_t=clock()) +#define MYTIMEDIFF(fin,ini) ((fin)-(ini)) +#define TIMER_RES_DIVIDER 1 +#define SAMPLE_TIME_IMPLEMENTATION 1 +#define EE_TICKS_PER_SEC (NSECS_PER_SEC / TIMER_RES_DIVIDER) + +/** Define Host specific (POSIX), or target specific global time variables. */ +static CORETIMETYPE start_time_val, stop_time_val; + +/* Function : start_time + This function will be called right before starting the timed portion of the benchmark. + + Implementation may be capturing a system timer (as implemented in the example code) + or zeroing some system parameters - e.g. setting the cpu clocks cycles to 0. +*/ +void start_time(void) { + GETMYTIME(&start_time_val ); +} +/* Function : stop_time + This function will be called right after ending the timed portion of the benchmark. + + Implementation may be capturing a system timer (as implemented in the example code) + or other system parameters - e.g. reading the current value of cpu cycles counter. +*/ +void stop_time(void) { + GETMYTIME(&stop_time_val ); +} +/* Function : get_time + Return an abstract "ticks" number that signifies time on the system. + + Actual value returned may be cpu cycles, milliseconds or any other value, + as long as it can be converted to seconds by . + This methodology is taken to accomodate any hardware or simulated platform. + The sample implementation returns millisecs by default, + and the resolution is controlled by +*/ +CORE_TICKS get_time(void) { + CORE_TICKS elapsed=(CORE_TICKS)(MYTIMEDIFF(stop_time_val, start_time_val)); + return elapsed; +} +/* Function : time_in_secs + Convert the value returned by get_time to seconds. + + The type is used to accomodate systems with no support for floating point. + Default implementation implemented by the EE_TICKS_PER_SEC macro above. +*/ +secs_ret time_in_secs(CORE_TICKS ticks) { + secs_ret retval=((secs_ret)ticks) / (secs_ret)EE_TICKS_PER_SEC; + return retval; +} + +ee_u32 default_num_contexts=1; + +/* Function : portable_init + Target specific initialization code + Test for some common mistakes. +*/ +void portable_init(core_portable *p, int *argc, char *argv[]) +{ + if (sizeof(ee_ptr_int) != sizeof(ee_u8 *)) { + ee_printf("ERROR! Please define ee_ptr_int to a type that holds a pointer!\n"); + } + if (sizeof(ee_u32) != 4) { + ee_printf("ERROR! Please define ee_u32 to a 32b unsigned type!\n"); + } + p->portable_id=1; +} +/* Function : portable_fini + Target specific final code +*/ +void portable_fini(core_portable *p) +{ + p->portable_id=0; +} + + diff --git a/simple/core_portme.h b/simple/core_portme.h new file mode 100755 index 0000000..e653349 --- /dev/null +++ b/simple/core_portme.h @@ -0,0 +1,184 @@ +/* File : core_portme.h */ + +/* + Author : Shay Gal-On, EEMBC + Legal : TODO! +*/ +/* Topic : Description + This file contains configuration constants required to execute on different platforms +*/ +#ifndef CORE_PORTME_H +#define CORE_PORTME_H +/************************/ +/* Data types and settings */ +/************************/ +/* Configuration : HAS_FLOAT + Define to 1 if the platform supports floating point. +*/ +#ifndef HAS_FLOAT +#define HAS_FLOAT 1 +#endif +/* Configuration : HAS_TIME_H + Define to 1 if platform has the time.h header file, + and implementation of functions thereof. +*/ +#ifndef HAS_TIME_H +#define HAS_TIME_H 1 +#endif +/* Configuration : USE_CLOCK + Define to 1 if platform has the time.h header file, + and implementation of functions thereof. +*/ +#ifndef USE_CLOCK +#define USE_CLOCK 1 +#endif +/* Configuration : HAS_STDIO + Define to 1 if the platform has stdio.h. +*/ +#ifndef HAS_STDIO +#define HAS_STDIO 1 +#endif +/* Configuration : HAS_PRINTF + Define to 1 if the platform has stdio.h and implements the printf function. +*/ +#ifndef HAS_PRINTF +#define HAS_PRINTF 1 +#endif + +/* Configuration : CORE_TICKS + Define type of return from the timing functions. + */ +#include +typedef clock_t CORE_TICKS; + +/* Definitions : COMPILER_VERSION, COMPILER_FLAGS, MEM_LOCATION + Initialize these strings per platform +*/ +#ifndef COMPILER_VERSION + #ifdef __GNUC__ + #define COMPILER_VERSION "GCC"__VERSION__ + #else + #define COMPILER_VERSION "Please put compiler version here (e.g. gcc 4.1)" + #endif +#endif +#ifndef COMPILER_FLAGS + #define COMPILER_FLAGS FLAGS_STR /* "Please put compiler flags here (e.g. -o3)" */ +#endif +#ifndef MEM_LOCATION + #define MEM_LOCATION "STACK" +#endif + +/* Data Types : + To avoid compiler issues, define the data types that need ot be used for 8b, 16b and 32b in . + + *Imprtant* : + ee_ptr_int needs to be the data type used to hold pointers, otherwise coremark may fail!!! +*/ +typedef signed short ee_s16; +typedef unsigned short ee_u16; +typedef signed int ee_s32; +typedef double ee_f32; +typedef unsigned char ee_u8; +typedef unsigned int ee_u32; +typedef ee_u32 ee_ptr_int; +typedef size_t ee_size_t; +/* align_mem : + This macro is used to align an offset to point to a 32b value. It is used in the Matrix algorithm to initialize the input memory blocks. +*/ +#define align_mem(x) (void *)(4 + (((ee_ptr_int)(x) - 1) & ~3)) + +/* Configuration : SEED_METHOD + Defines method to get seed values that cannot be computed at compile time. + + Valid values : + SEED_ARG - from command line. + SEED_FUNC - from a system function. + SEED_VOLATILE - from volatile variables. +*/ +#ifndef SEED_METHOD +#define SEED_METHOD SEED_VOLATILE +#endif + +/* Configuration : MEM_METHOD + Defines method to get a block of memry. + + Valid values : + MEM_MALLOC - for platforms that implement malloc and have malloc.h. + MEM_STATIC - to use a static memory array. + MEM_STACK - to allocate the data block on the stack (NYI). +*/ +#ifndef MEM_METHOD +#define MEM_METHOD MEM_STACK +#endif + +/* Configuration : MULTITHREAD + Define for parallel execution + + Valid values : + 1 - only one context (default). + N>1 - will execute N copies in parallel. + + Note : + If this flag is defined to more then 1, an implementation for launching parallel contexts must be defined. + + Two sample implementations are provided. Use or to enable them. + + It is valid to have a different implementation of and in , + to fit a particular architecture. +*/ +#ifndef MULTITHREAD +#define MULTITHREAD 1 +#define USE_PTHREAD 0 +#define USE_FORK 0 +#define USE_SOCKET 0 +#endif + +/* Configuration : MAIN_HAS_NOARGC + Needed if platform does not support getting arguments to main. + + Valid values : + 0 - argc/argv to main is supported + 1 - argc/argv to main is not supported + + Note : + This flag only matters if MULTITHREAD has been defined to a value greater then 1. +*/ +#ifndef MAIN_HAS_NOARGC +#define MAIN_HAS_NOARGC 0 +#endif + +/* Configuration : MAIN_HAS_NORETURN + Needed if platform does not support returning a value from main. + + Valid values : + 0 - main returns an int, and return value will be 0. + 1 - platform does not support returning a value from main +*/ +#ifndef MAIN_HAS_NORETURN +#define MAIN_HAS_NORETURN 0 +#endif + +/* Variable : default_num_contexts + Not used for this simple port, must cintain the value 1. +*/ +extern ee_u32 default_num_contexts; + +typedef struct CORE_PORTABLE_S { + ee_u8 portable_id; +} core_portable; + +/* target specific init/fini */ +void portable_init(core_portable *p, int *argc, char *argv[]); +void portable_fini(core_portable *p); + +#if !defined(PROFILE_RUN) && !defined(PERFORMANCE_RUN) && !defined(VALIDATION_RUN) +#if (TOTAL_DATA_SIZE==1200) +#define PROFILE_RUN 1 +#elif (TOTAL_DATA_SIZE==2000) +#define PERFORMANCE_RUN 1 +#else +#define VALIDATION_RUN 1 +#endif +#endif + +#endif /* CORE_PORTME_H */ diff --git a/simple/core_portme.mak b/simple/core_portme.mak new file mode 100755 index 0000000..9564cc3 --- /dev/null +++ b/simple/core_portme.mak @@ -0,0 +1,44 @@ +#File : core_portme.mak + +# Flag : OUTFLAG +# Use this flag to define how to to get an executable (e.g -o) +OUTFLAG= -o +# Flag : CC +# Use this flag to define compiler to use +CC = gcc +# Flag : CFLAGS +# Use this flag to define compiler options. Note, you can add compiler options from the command line using XCFLAGS="other flags" +PORT_CFLAGS = -O2 +FLAGS_STR = "$(PORT_CFLAGS) $(XCFLAGS) $(XLFLAGS) $(LFLAGS_END)" +CFLAGS = $(PORT_CFLAGS) -I$(PORT_DIR) -I. -DFLAGS_STR=\"$(FLAGS_STR)\" +#Flag : LFLAGS_END +# Define any libraries needed for linking or other flags that should come at the end of the link line (e.g. linker scripts). +# Note : On certain platforms, the default clock_gettime implementation is supported but requires linking of librt. +LFLAGS_END = +# Flag : PORT_SRCS +# Port specific source files can be added here +PORT_SRCS = $(PORT_DIR)/core_portme.c +# Flag : LOAD +# For a simple port, we assume self hosted compile and run, no load needed. + +# Flag : RUN +# For a simple port, we assume self hosted compile and run, simple invocation of the executable + +#For native compilation and execution +LOAD = echo Loading done +RUN = + +OEXT = .o +EXE = .exe + +# Target : port_pre% and port_post% +# For the purpose of this simple port, no pre or post steps needed. + +.PHONY : port_prebuild port_postbuild port_prerun port_postrun port_preload port_postload +port_pre% port_post% : + +# FLAG : OPATH +# Path to the output folder. Default - current folder. +OPATH = ./ +MKDIR = mkdir -p +