Merge "Test alpha after mutating VD" into nyc-dev
diff --git a/apps/CtsVerifier/AndroidManifest.xml b/apps/CtsVerifier/AndroidManifest.xml
index 6ca7861..53a2ab1 100644
--- a/apps/CtsVerifier/AndroidManifest.xml
+++ b/apps/CtsVerifier/AndroidManifest.xml
@@ -45,8 +45,8 @@
android:required="false" />
<uses-feature android:name="android.hardware.camera.autofocus"
android:required="false" />
- <uses-feature android:name="android.software.vr.mode"
- android:required="false" />
+ <uses-feature android:name="android.software.vr.mode" android:required="false" />
+ <uses-feature android:name="android.hardware.vr.high_performance" android:required="false"/>
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.WAKE_LOCK" />
@@ -1248,6 +1248,8 @@
<category android:name="android.cts.intent.category.MANUAL_TEST" />
</intent-filter>
<meta-data android:name="test_category" android:value="@string/test_category_vr" />
+ <meta-data android:name="test_required_features"
+ android:value="android.software.vr.mode" />
</activity>
<activity android:name=".vr.MockVrActivity"
diff --git a/apps/CtsVerifier/res/values/strings.xml b/apps/CtsVerifier/res/values/strings.xml
index 97eae8c..73557c8 100644
--- a/apps/CtsVerifier/res/values/strings.xml
+++ b/apps/CtsVerifier/res/values/strings.xml
@@ -1048,23 +1048,28 @@
<string name="p2p_service_discovery_requester">Service Discovery Requester</string>
<string name="p2p_go_neg_responder_info">
- Start the \"GO Negotiation Requester Test\" on the other device and follow
+ Go to the Wi-Fi settings and forget all remembered networks. Then
+ start the \"GO Negotiation Requester Test\" on the other device and follow
the instructions.</string>
<string name="p2p_accept_client_info">
- Start the \"Group Client Test\" on the other device and follow
+ Go to the Wi-Fi settings and forget all remembered networks. Then
+ start the \"Group Client Test\" on the other device and follow
the instructions.</string>
<string name="p2p_service_discovery_responder_info">
Start the \"Service Discovery Requester Test\" on the other device and follow
the instructions.</string>
<string name="p2p_go_neg_requester_info">
- Start the \"GO Negotiation Responder Test\" on the other device.
+ Go to the Wi-Fi settings and forget all remembered networks. Then
+ start the \"GO Negotiation Responder Test\" on the other device.
Then run each test individually by clicking on it\'s name.</string>
<string name="p2p_join_go_info">
- Start the \"Group Owner Test\" on the other device.
+ Go to the Wi-Fi settings and forget all remembered networks. Then
+ start the \"Group Owner Test\" on the other device.
Then run each test individually by clicking on it\'s name.</string>
<string name="p2p_service_discovery_requester_info">
- Start the \"Service Discovery Responder Test\" on the other device.
+ Go to the Wi-Fi settings and forget all remembered networks. Then
+ start the \"Service Discovery Responder Test\" on the other device.
Then run each test individually by clicking on it\'s name.</string>
<string name="p2p_not_enabled">Wi-Fi is not enabled</string>
@@ -1075,18 +1080,21 @@
<string name="p2p_result_success">Test passed successfully.</string>
<string name="p2p_go_neg_responder_ready">
- The go negotiation responder is now ready to start. Start
- the \"GO Negotiation Requester Test\" on the other device.
+ The go negotiation responder is now ready to start.
+ Go to the Wi-Fi settings and forget all remembered networks. Then
+ start the \"GO Negotiation Requester Test\" on the other device.
Keep the screen here until all tests on the other device are
finished.</string>
<string name="p2p_go_ready">
- The group owner is now ready to start. Start the \"Join
- Group Test\" on the other device.
+ The group owner is now ready to start.
+ Go to the Wi-Fi settings and forget all remembered networks. Then
+ start the \"Join Group Test\" on the other device.
Keep the screen here until all tests on the other device are
finished.</string>
<string name="p2p_service_responder_ready">
- The service responder is now ready to start. Start the
- \"Service Discovery Requester Test\" on the other device.
+ The service responder is now ready to start.
+ Go to the Wi-Fi settings and forget all remembered networks. Then
+ start the \"Service Discovery Requester Test\" on the other device.
Keep the screen here until all tests on the other device are
finished.</string>
diff --git a/common/host-side/tradefed/src/com/android/compatibility/common/tradefed/testtype/CompatibilityTest.java b/common/host-side/tradefed/src/com/android/compatibility/common/tradefed/testtype/CompatibilityTest.java
index a9d7f18..48b7d3b 100644
--- a/common/host-side/tradefed/src/com/android/compatibility/common/tradefed/testtype/CompatibilityTest.java
+++ b/common/host-side/tradefed/src/com/android/compatibility/common/tradefed/testtype/CompatibilityTest.java
@@ -168,13 +168,17 @@
description = "Take a screenshot on every test failure.")
private boolean mScreenshotOnFailure = false;
+ @Option(name = "reboot-before-test",
+ description = "Reboot the device before the test suite starts.")
+ private boolean mRebootBeforeTest = false;
+
@Option(name = "reboot-on-failure",
description = "Reboot the device after every test failure.")
private boolean mRebootOnFailure = false;
- @Option(name = "reboot-before-test",
- description = "Reboot the device before the test suite starts.")
- private boolean mRebootBeforeTest = false;
+ @Option(name = "reboot-per-module",
+ description = "Reboot the device before every module run.")
+ private boolean mRebootPerModule = false;
@Option(name = "skip-connectivity-check",
description = "Don't verify device connectivity between module execution.")
@@ -286,6 +290,18 @@
for (int i = 0; i < moduleCount; i++) {
IModuleDef module = modules.get(i);
long start = System.currentTimeMillis();
+
+ if (mRebootPerModule) {
+ if ("user".equals(mDevice.getProperty("ro.build.type"))) {
+ CLog.e("reboot-per-module should only be used during development, "
+ + "this is a\" user\" build device");
+ } else {
+ CLog.logAndDisplay(LogLevel.INFO, "Rebooting device before starting next "
+ + "module");
+ mDevice.reboot();
+ }
+ }
+
try {
module.run(listener);
} catch (DeviceUnresponsiveException due) {
diff --git a/hostsidetests/devicepolicy/app/DeviceOwner/AndroidManifest.xml b/hostsidetests/devicepolicy/app/DeviceOwner/AndroidManifest.xml
index 6039b6e..64d4079 100644
--- a/hostsidetests/devicepolicy/app/DeviceOwner/AndroidManifest.xml
+++ b/hostsidetests/devicepolicy/app/DeviceOwner/AndroidManifest.xml
@@ -25,7 +25,8 @@
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
<uses-permission android:name="android.permission.INTERACT_ACROSS_USERS" />
- <application
+ <!-- Add a network security config that trusts user added CAs for tests -->
+ <application android:networkSecurityConfig="@xml/network_security_config"
android:testOnly="true">
<uses-library android:name="android.test.runner" />
@@ -65,9 +66,6 @@
android:name="com.android.cts.deviceowner.LockTaskTest$IntentReceivingActivity"
android:taskAffinity="com.android.cts.deviceowner.LockTaskTest.IntentReceivingActivity"
/>
- <!-- Add a network security config that trusts user added CAs for tests -->
- <meta-data android:name="android.security.net.config"
- android:resource="@xml/network_security_config" />
</application>
<instrumentation android:name="android.support.test.runner.AndroidJUnitRunner"
diff --git a/hostsidetests/sustainedperf/Android.mk b/hostsidetests/sustainedperf/Android.mk
new file mode 100644
index 0000000..22c6d45
--- /dev/null
+++ b/hostsidetests/sustainedperf/Android.mk
@@ -0,0 +1,31 @@
+# Copyright (C) 2014 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+
+LOCAL_MODULE_TAGS := tests
+
+# tag this module as a cts test artifact
+LOCAL_COMPATIBILITY_SUITE := cts
+
+LOCAL_MODULE := CtsSustainedPerformanceHostTestCases
+LOCAL_JAVA_LIBRARIES := cts-tradefed tradefed-prebuilt compatibility-host-util
+
+include $(BUILD_HOST_JAVA_LIBRARY)
+
+include $(call all-makefiles-under,$(LOCAL_PATH))
diff --git a/hostsidetests/sustainedperf/AndroidTest.xml b/hostsidetests/sustainedperf/AndroidTest.xml
new file mode 100644
index 0000000..ae5cc27
--- /dev/null
+++ b/hostsidetests/sustainedperf/AndroidTest.xml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 The Android Open Source Project
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<configuration description="Config for CTS Sustained Performance host test cases">
+ <target_preparer class="com.android.compatibility.common.tradefed.targetprep.ApkInstaller">
+ <option name="cleanup-apks" value="true" />
+ <option name="test-file-name" value="CtsSustainedPerformanceTestCases.apk" />
+ </target_preparer>
+ <target_preparer class="com.android.compatibility.common.tradefed.targetprep.ApkInstaller">
+ <option name="cleanup-apks" value="true" />
+ <option name="test-file-name" value="CtsSustainedPerformanceDeviceTestApp.apk" />
+ </target_preparer>
+ <target_preparer class="com.android.compatibility.common.tradefed.targetprep.FilePusher">
+ <option name="cleanup" value="true" />
+ <option name="push" value="dhry->/data/local/tmp/dhry" />
+ <option name="append-bitness" value="true" />
+ </target_preparer>
+ <test class="com.android.compatibility.common.tradefed.testtype.JarHostTest" >
+ <option name="jar" value="CtsSustainedPerformanceHostTestCases.jar" />
+ </test>
+</configuration>
diff --git a/hostsidetests/sustainedperf/app/Android.mk b/hostsidetests/sustainedperf/app/Android.mk
new file mode 100644
index 0000000..41f61e4
--- /dev/null
+++ b/hostsidetests/sustainedperf/app/Android.mk
@@ -0,0 +1,37 @@
+# Copyright (C) 2014 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+# Don't include this package in any target
+LOCAL_MODULE_TAGS := tests
+# When built, explicitly put it in the data partition.
+LOCAL_MODULE_PATH := $(TARGET_OUT_DATA_APPS)
+
+LOCAL_DEX_PREOPT := false
+
+LOCAL_PROGUARD_ENABLED := disabled
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+
+# tag this module as a cts test artifact
+LOCAL_COMPATIBILITY_SUITE := cts
+
+LOCAL_PACKAGE_NAME := CtsSustainedPerformanceDeviceTestApp
+
+LOCAL_SDK_VERSION := current
+
+include $(BUILD_PACKAGE)
diff --git a/hostsidetests/sustainedperf/app/AndroidManifest.xml b/hostsidetests/sustainedperf/app/AndroidManifest.xml
new file mode 100755
index 0000000..eff4a7f
--- /dev/null
+++ b/hostsidetests/sustainedperf/app/AndroidManifest.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="android.test.app">
+
+ <application>
+ <activity android:name=".DeviceTestActivity" >
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN" />
+ <category android:name="android.intent.category.LAUNCHER" />
+ </intent-filter>
+ </activity>
+ </application>
+
+</manifest>
+
diff --git a/hostsidetests/sustainedperf/app/src/android/test/app/DeviceTestActivity.java b/hostsidetests/sustainedperf/app/src/android/test/app/DeviceTestActivity.java
new file mode 100644
index 0000000..92b8f1d
--- /dev/null
+++ b/hostsidetests/sustainedperf/app/src/android/test/app/DeviceTestActivity.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.app;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.util.Log;
+import android.os.PowerManager;
+import java.lang.Override;
+import android.content.Context;
+
+public class DeviceTestActivity extends Activity {
+
+ @Override
+ public void onCreate(Bundle icicle) {
+ super.onCreate(icicle);
+ PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
+ if (pm.isSustainedPerformanceModeSupported()) {
+ Log.i("DeviceTestActivity", "Sustained Performance Mode is supported\n");
+ }
+ }
+}
diff --git a/hostsidetests/sustainedperf/dhrystone/Android.mk b/hostsidetests/sustainedperf/dhrystone/Android.mk
new file mode 100644
index 0000000..4c6b53d
--- /dev/null
+++ b/hostsidetests/sustainedperf/dhrystone/Android.mk
@@ -0,0 +1,18 @@
+LOCAL_PATH:= $(call my-dir)
+
+## sources have been created from Drystone-2.1.sh with below command:
+# ./Drystone-2.1.sh
+# sed -i 's/printf (" Ptr_Comp: %d\\n", (int) /printf (" Ptr_Comp: %p\\n", /g' dhry_1.c
+# sed -i 's,^} /\* Proc_,return 0; } /\* Proc_,g' *.c
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := dhry
+LOCAL_SRC_FILES := dhry_1.c dhry_2.c
+LOCAL_CFLAGS := -O3 -fno-inline-functions -DMSC_CLOCK -DCLK_TCK=1000000
+LOCAL_CFLAGS += -Wno-return-type -Wno-implicit-function-declaration -Wno-implicit-int
+# Include both the 32 and 64 bit versions
+LOCAL_MULTILIB := both
+LOCAL_MODULE_STEM_32 := $(LOCAL_MODULE)32
+LOCAL_MODULE_STEM_64 := $(LOCAL_MODULE)64
+LOCAL_COMPATIBILITY_SUITE := cts
+include $(BUILD_EXECUTABLE)
diff --git a/hostsidetests/sustainedperf/dhrystone/Drystone-2.1.sh b/hostsidetests/sustainedperf/dhrystone/Drystone-2.1.sh
new file mode 100755
index 0000000..f2bf2c1
--- /dev/null
+++ b/hostsidetests/sustainedperf/dhrystone/Drystone-2.1.sh
@@ -0,0 +1,1424 @@
+#! /bin/sh
+# This is a shell archive, meaning:
+# 1. Remove everything above the #! /bin/sh line.
+# 2. Save the resulting text in a file.
+# 3. Execute the file with /bin/sh (not csh) to create:
+# Rationale
+# dhry.h
+# dhry_1.c
+# dhry_2.c
+# This archive created: Wed Jul 6 16:50:06 1988
+export PATH; PATH=/bin:/usr/bin:$PATH
+if test -f 'Rationale'
+then
+ echo shar: "will not over-write existing file 'Rationale'"
+else
+sed 's/^X//' << \SHAR_EOF > 'Rationale'
+XDhrystone Benchmark: Rationale for Version 2 and Measurement Rules
+X
+X Reinhold P. Weicker
+X Siemens AG, E STE 35
+X Postfach 3240
+X D-8520 Erlangen
+X Germany (West)
+X
+X
+X
+X
+XThe Dhrystone benchmark program [1] has become a popular benchmark for
+XCPU/compiler performance measurement, in particular in the area of
+Xminicomputers, workstations, PC's and microprocesors. It apparently
+Xsatisfies a need for an easy-to-use integer benchmark; it gives a first
+Xperformance indication which is more meaningful than MIPS numbers
+Xwhich, in their literal meaning (million instructions per second),
+Xcannot be used across different instruction sets (e.g. RISC vs. CISC).
+XWith the increasing use of the benchmark, it seems necessary to
+Xreconsider the benchmark and to check whether it can still fulfill this
+Xfunction. Version 2 of Dhrystone is the result of such a re-
+Xevaluation, it has been made for two reasons:
+X
+Xo Dhrystone has been published in Ada [1], and Versions in Ada, Pascal
+X and C have been distributed by Reinhold Weicker via floppy disk.
+X However, the version that was used most often for benchmarking has
+X been the version made by Rick Richardson by another translation from
+X the Ada version into the C programming language, this has been the
+X version distributed via the UNIX network Usenet [2].
+X
+X There is an obvious need for a common C version of Dhrystone, since C
+X is at present the most popular system programming language for the
+X class of systems (microcomputers, minicomputers, workstations) where
+X Dhrystone is used most. There should be, as far as possible, only
+X one C version of Dhrystone such that results can be compared without
+X restrictions. In the past, the C versions distributed by Rick
+X Richardson (Version 1.1) and by Reinhold Weicker had small (though
+X not significant) differences.
+X
+X Together with the new C version, the Ada and Pascal versions have
+X been updated as well.
+X
+Xo As far as it is possible without changes to the Dhrystone statistics,
+X optimizing compilers should be prevented from removing significant
+X statements. It has turned out in the past that optimizing compilers
+X suppressed code generation for too many statements (by "dead code
+X removal" or "dead variable elimination"). This has lead to the
+X danger that benchmarking results obtained by a naive application of
+X Dhrystone - without inspection of the code that was generated - could
+X become meaningless.
+X
+XThe overall policiy for version 2 has been that the distribution of
+Xstatements, operand types and operand locality described in [1] should
+Xremain unchanged as much as possible. (Very few changes were
+Xnecessary; their impact should be negligible.) Also, the order of
+Xstatements should remain unchanged. Although I am aware of some
+Xcritical remarks on the benchmark - I agree with several of them - and
+Xknow some suggestions for improvement, I didn't want to change the
+Xbenchmark into something different from what has become known as
+X"Dhrystone"; the confusion generated by such a change would probably
+Xoutweight the benefits. If I were to write a new benchmark program, I
+Xwouldn't give it the name "Dhrystone" since this denotes the program
+Xpublished in [1]. However, I do recognize the need for a larger number
+Xof representative programs that can be used as benchmarks; users should
+Xalways be encouraged to use more than just one benchmark.
+X
+XThe new versions (version 2.1 for C, Pascal and Ada) will be
+Xdistributed as widely as possible. (Version 2.1 differs from version
+X2.0 distributed via the UNIX Network Usenet in March 1988 only in a few
+Xcorrections for minor deficiencies found by users of version 2.0.)
+XReaders who want to use the benchmark for their own measurements can
+Xobtain a copy in machine-readable form on floppy disk (MS-DOS or XENIX
+Xformat) from the author.
+X
+X
+XIn general, version 2 follows - in the parts that are significant for
+Xperformance measurement, i.e. within the measurement loop - the
+Xpublished (Ada) version and the C versions previously distributed.
+XWhere the versions distributed by Rick Richardson [2] and Reinhold
+XWeicker have been different, it follows the version distributed by
+XReinhold Weicker. (However, the differences have been so small that
+Xtheir impact on execution time in all likelihood has been negligible.)
+XThe initialization and UNIX instrumentation part - which had been
+Xomitted in [1] - follows mostly the ideas of Rick Richardson [2].
+XHowever, any changes in the initialization part and in the printing of
+Xthe result have no impact on performance measurement since they are
+Xoutside the measaurement loop. As a concession to older compilers,
+Xnames have been made unique within the first 8 characters for the C
+Xversion.
+X
+XThe original publication of Dhrystone did not contain any statements
+Xfor time measurement since they are necessarily system-dependent.
+XHowever, it turned out that it is not enough just to inclose the main
+Xprocedure of Dhrystone in a loop and to measure the execution time. If
+Xthe variables that are computed are not used somehow, there is the
+Xdanger that the compiler considers them as "dead variables" and
+Xsuppresses code generation for a part of the statements. Therefore in
+Xversion 2 all variables of "main" are printed at the end of the
+Xprogram. This also permits some plausibility control for correct
+Xexecution of the benchmark.
+X
+XAt several places in the benchmark, code has been added, but only in
+Xbranches that are not executed. The intention is that optimizing
+Xcompilers should be prevented from moving code out of the measurement
+Xloop, or from removing code altogether. Statements that are executed
+Xhave been changed in very few places only. In these cases, only the
+Xrole of some operands has been changed, and it was made sure that the
+Xnumbers defining the "Dhrystone distribution" (distribution of
+Xstatements, operand types and locality) still hold as much as possible.
+XExcept for sophisticated optimizing compilers, execution times for
+Xversion 2.1 should be the same as for previous versions.
+X
+XBecause of the self-imposed limitation that the order and distribution
+Xof the executed statements should not be changed, there are still cases
+Xwhere optimizing compilers may not generate code for some statements.
+XTo a certain degree, this is unavoidable for small synthetic
+Xbenchmarks. Users of the benchmark are advised to check code listings
+Xwhether code is generated for all statements of Dhrystone.
+X
+XContrary to the suggestion in the published paper and its realization
+Xin the versions previously distributed, no attempt has been made to
+Xsubtract the time for the measurement loop overhead. (This calculation
+Xhas proven difficult to implement in a correct way, and its omission
+Xmakes the program simpler.) However, since the loop check is now part
+Xof the benchmark, this does have an impact - though a very minor one -
+Xon the distribution statistics which have been updated for this
+Xversion.
+X
+X
+XIn this section, all changes are described that affect the measurement
+Xloop and that are not just renamings of variables. All remarks refer to
+Xthe C version; the other language versions have been updated similarly.
+X
+XIn addition to adding the measurement loop and the printout statements,
+Xchanges have been made at the following places:
+X
+Xo In procedure "main", three statements have been added in the non-
+X executed "then" part of the statement
+X if (Enum_Loc == Func_1 (Ch_Index, 'C'))
+X they are
+X strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 3'RD STRING");
+X Int_2_Loc = Run_Index;
+X Int_Glob = Run_Index;
+X The string assignment prevents movement of the preceding assignment
+X to Str_2_Loc (5'th statement of "main") out of the measurement loop
+X (This probably will not happen for the C version, but it did happen
+X with another language and compiler.) The assignment to Int_2_Loc
+X prevents value propagation for Int_2_Loc, and the assignment to
+X Int_Glob makes the value of Int_Glob possibly dependent from the
+X value of Run_Index.
+X
+Xo In the three arithmetic computations at the end of the measurement
+X loop in "main ", the role of some variables has been exchanged, to
+X prevent the division from just cancelling out the multiplication as
+X it was in [1]. A very smart compiler might have recognized this and
+X suppressed code generation for the division.
+X
+Xo For Proc_2, no code has been changed, but the values of the actual
+X parameter have changed due to changes in "main".
+X
+Xo In Proc_4, the second assignment has been changed from
+X Bool_Loc = Bool_Loc | Bool_Glob;
+X to
+X Bool_Glob = Bool_Loc | Bool_Glob;
+X It now assigns a value to a global variable instead of a local
+X variable (Bool_Loc); Bool_Loc would be a "dead variable" which is not
+X used afterwards.
+X
+Xo In Func_1, the statement
+X Ch_1_Glob = Ch_1_Loc;
+X was added in the non-executed "else" part of the "if" statement, to
+X prevent the suppression of code generation for the assignment to
+X Ch_1_Loc.
+X
+Xo In Func_2, the second character comparison statement has been changed
+X to
+X if (Ch_Loc == 'R')
+X ('R' instead of 'X') because a comparison with 'X' is implied in the
+X preceding "if" statement.
+X
+X Also in Func_2, the statement
+X Int_Glob = Int_Loc;
+X has been added in the non-executed part of the last "if" statement,
+X in order to prevent Int_Loc from becoming a dead variable.
+X
+Xo In Func_3, a non-executed "else" part has been added to the "if"
+X statement. While the program would not be incorrect without this
+X "else" part, it is considered bad programming practice if a function
+X can be left without a return value.
+X
+X To compensate for this change, the (non-executed) "else" part in the
+X "if" statement of Proc_3 was removed.
+X
+XThe distribution statistics have been changed only by the addition of
+Xthe measurement loop iteration (1 additional statement, 4 additional
+Xlocal integer operands) and by the change in Proc_4 (one operand
+Xchanged from local to global). The distribution statistics in the
+Xcomment headers have been updated accordingly.
+X
+X
+XThe string operations (string assignment and string comparison) have
+Xnot been changed, to keep the program consistent with the original
+Xversion.
+X
+XThere has been some concern that the string operations are over-
+Xrepresented in the program, and that execution time is dominated by
+Xthese operations. This was true in particular when optimizing
+Xcompilers removed too much code in the main part of the program, this
+Xshould have been mitigated in version 2.
+X
+XIt should be noted that this is a language-dependent issue: Dhrystone
+Xwas first published in Ada, and with Ada or Pascal semantics, the time
+Xspent in the string operations is, at least in all implementations
+Xknown to me, considerably smaller. In Ada and Pascal, assignment and
+Xcomparison of strings are operators defined in the language, and the
+Xupper bounds of the strings occuring in Dhrystone are part of the type
+Xinformation known at compilation time. The compilers can therefore
+Xgenerate efficient inline code. In C, string assignemt and comparisons
+Xare not part of the language, so the string operations must be
+Xexpressed in terms of the C library functions "strcpy" and "strcmp".
+X(ANSI C allows an implementation to use inline code for these
+Xfunctions.) In addition to the overhead caused by additional function
+Xcalls, these functions are defined for null-terminated strings where
+Xthe length of the strings is not known at compilation time; the
+Xfunction has to check every byte for the termination condition (the
+Xnull byte).
+X
+XObviously, a C library which includes efficiently coded "strcpy" and
+X"strcmp" functions helps to obtain good Dhrystone results. However, I
+Xdon't think that this is unfair since string functions do occur quite
+Xfrequently in real programs (editors, command interpreters, etc.). If
+Xthe strings functions are implemented efficiently, this helps real
+Xprograms as well as benchmark programs.
+X
+XI admit that the string comparison in Dhrystone terminates later (after
+Xscanning 20 characters) than most string comparisons in real programs.
+XFor consistency with the original benchmark, I didn't change the
+Xprogram despite this weakness.
+X
+X
+XWhen Dhrystone is used, the following "ground rules" apply:
+X
+Xo Separate compilation (Ada and C versions)
+X
+X As mentioned in [1], Dhrystone was written to reflect actual
+X programming practice in systems programming. The division into
+X several compilation units (5 in the Ada version, 2 in the C version)
+X is intended, as is the distribution of inter-module and intra-module
+X subprogram calls. Although on many systems there will be no
+X difference in execution time to a Dhrystone version where all
+X compilation units are merged into one file, the rule is that separate
+X compilation should be used. The intention is that real programming
+X practice, where programs consist of several independently compiled
+X units, should be reflected. This also has implies that the compiler,
+X while compiling one unit, has no information about the use of
+X variables, register allocation etc. occuring in other compilation
+X units. Although in real life compilation units will probably be
+X larger, the intention is that these effects of separate compilation
+X are modeled in Dhrystone.
+X
+X A few language systems have post-linkage optimization available
+X (e.g., final register allocation is performed after linkage). This
+X is a borderline case: Post-linkage optimization involves additional
+X program preparation time (although not as much as compilation in one
+X unit) which may prevent its general use in practical programming. I
+X think that since it defeats the intentions given above, it should not
+X be used for Dhrystone.
+X
+X Unfortunately, ISO/ANSI Pascal does not contain language features for
+X separate compilation. Although most commercial Pascal compilers
+X provide separate compilation in some way, we cannot use it for
+X Dhrystone since such a version would not be portable. Therefore, no
+X attempt has been made to provide a Pascal version with several
+X compilation units.
+X
+Xo No procedure merging
+X
+X Although Dhrystone contains some very short procedures where
+X execution would benefit from procedure merging (inlining, macro
+X expansion of procedures), procedure merging is not to be used. The
+X reason is that the percentage of procedure and function calls is part
+X of the "Dhrystone distribution" of statements contained in [1]. This
+X restriction does not hold for the string functions of the C version
+X since ANSI C allows an implementation to use inline code for these
+X functions.
+X
+X
+X
+Xo Other optimizations are allowed, but they should be indicated
+X
+X It is often hard to draw an exact line between "normal code
+X generation" and "optimization" in compilers: Some compilers perform
+X operations by default that are invoked in other compilers only when
+X optimization is explicitly requested. Also, we cannot avoid that in
+X benchmarking people try to achieve results that look as good as
+X possible. Therefore, optimizations performed by compilers - other
+X than those listed above - are not forbidden when Dhrystone execution
+X times are measured. Dhrystone is not intended to be non-optimizable
+X but is intended to be similarly optimizable as normal programs. For
+X example, there are several places in Dhrystone where performance
+X benefits from optimizations like common subexpression elimination,
+X value propagation etc., but normal programs usually also benefit from
+X these optimizations. Therefore, no effort was made to artificially
+X prevent such optimizations. However, measurement reports should
+X indicate which compiler optimization levels have been used, and
+X reporting results with different levels of compiler optimization for
+X the same hardware is encouraged.
+X
+Xo Default results are those without "register" declarations (C version)
+X
+X When Dhrystone results are quoted without additional qualification,
+X they should be understood as results obtained without use of the
+X "register" attribute. Good compilers should be able to make good use
+X of registers even without explicit register declarations ([3], p.
+X 193).
+X
+XOf course, for experimental purposes, post-linkage optimization,
+Xprocedure merging and/or compilation in one unit can be done to
+Xdetermine their effects. However, Dhrystone numbers obtained under
+Xthese conditions should be explicitly marked as such; "normal"
+XDhrystone results should be understood as results obtained following
+Xthe ground rules listed above.
+X
+XIn any case, for serious performance evaluation, users are advised to
+Xask for code listings and to check them carefully. In this way, when
+Xresults for different systems are compared, the reader can get a
+Xfeeling how much performance difference is due to compiler optimization
+Xand how much is due to hardware speed.
+X
+X
+XThe C version 2.1 of Dhrystone has been developed in cooperation with
+XRick Richardson (Tinton Falls, NJ), it incorporates many ideas from the
+X"Version 1.1" distributed previously by him over the UNIX network
+XUsenet. Through his activity with Usenet, Rick Richardson has made a
+Xvery valuable contribution to the dissemination of the benchmark. I
+Xalso thank Chaim Benedelac (National Semiconductor), David Ditzel
+X(SUN), Earl Killian and John Mashey (MIPS), Alan Smith and Rafael
+XSaavedra-Barrera (UC at Berkeley) for their help with comments on
+Xearlier versions of the benchmark.
+X
+X
+X[1]
+X Reinhold P. Weicker: Dhrystone: A Synthetic Systems Programming
+X Benchmark.
+X Communications of the ACM 27, 10 (Oct. 1984), 1013-1030
+X
+X[2]
+X Rick Richardson: Dhrystone 1.1 Benchmark Summary (and Program Text)
+X Informal Distribution via "Usenet", Last Version Known to me: Sept.
+X 21, 1987
+X
+X[3]
+X Brian W. Kernighan and Dennis M. Ritchie: The C Programming
+X Language.
+X Prentice-Hall, Englewood Cliffs (NJ) 1978
+X
+X
+X
+X
+X
+SHAR_EOF
+fi
+if test -f 'dhry.h'
+then
+ echo shar: "will not over-write existing file 'dhry.h'"
+else
+sed 's/^X//' << \SHAR_EOF > 'dhry.h'
+X/*
+X ****************************************************************************
+X *
+X * "DHRYSTONE" Benchmark Program
+X * -----------------------------
+X *
+X * Version: C, Version 2.1
+X *
+X * File: dhry.h (part 1 of 3)
+X *
+X * Date: May 17, 1988
+X *
+X * Author: Reinhold P. Weicker
+X * Siemens AG, E STE 35
+X * Postfach 3240
+X * 8520 Erlangen
+X * Germany (West)
+X * Phone: [xxx-49]-9131-7-20330
+X * (8-17 Central European Time)
+X * Usenet: ..!mcvax!unido!estevax!weicker
+X *
+X * Original Version (in Ada) published in
+X * "Communications of the ACM" vol. 27., no. 10 (Oct. 1984),
+X * pp. 1013 - 1030, together with the statistics
+X * on which the distribution of statements etc. is based.
+X *
+X * In this C version, the following C library functions are used:
+X * - strcpy, strcmp (inside the measurement loop)
+X * - printf, scanf (outside the measurement loop)
+X * In addition, Berkeley UNIX system calls "times ()" or "time ()"
+X * are used for execution time measurement. For measurements
+X * on other systems, these calls have to be changed.
+X *
+X * Collection of Results:
+X * Reinhold Weicker (address see above) and
+X *
+X * Rick Richardson
+X * PC Research. Inc.
+X * 94 Apple Orchard Drive
+X * Tinton Falls, NJ 07724
+X * Phone: (201) 389-8963 (9-17 EST)
+X * Usenet: ...!uunet!pcrat!rick
+X *
+X * Please send results to Rick Richardson and/or Reinhold Weicker.
+X * Complete information should be given on hardware and software used.
+X * Hardware information includes: Machine type, CPU, type and size
+X * of caches; for microprocessors: clock frequency, memory speed
+X * (number of wait states).
+X * Software information includes: Compiler (and runtime library)
+X * manufacturer and version, compilation switches, OS version.
+X * The Operating System version may give an indication about the
+X * compiler; Dhrystone itself performs no OS calls in the measurement loop.
+X *
+X * The complete output generated by the program should be mailed
+X * such that at least some checks for correctness can be made.
+X *
+X ***************************************************************************
+X *
+X * History: This version C/2.1 has been made for two reasons:
+X *
+X * 1) There is an obvious need for a common C version of
+X * Dhrystone, since C is at present the most popular system
+X * programming language for the class of processors
+X * (microcomputers, minicomputers) where Dhrystone is used most.
+X * There should be, as far as possible, only one C version of
+X * Dhrystone such that results can be compared without
+X * restrictions. In the past, the C versions distributed
+X * by Rick Richardson (Version 1.1) and by Reinhold Weicker
+X * had small (though not significant) differences.
+X *
+X * 2) As far as it is possible without changes to the Dhrystone
+X * statistics, optimizing compilers should be prevented from
+X * removing significant statements.
+X *
+X * This C version has been developed in cooperation with
+X * Rick Richardson (Tinton Falls, NJ), it incorporates many
+X * ideas from the "Version 1.1" distributed previously by
+X * him over the UNIX network Usenet.
+X * I also thank Chaim Benedelac (National Semiconductor),
+X * David Ditzel (SUN), Earl Killian and John Mashey (MIPS),
+X * Alan Smith and Rafael Saavedra-Barrera (UC at Berkeley)
+X * for their help with comments on earlier versions of the
+X * benchmark.
+X *
+X * Changes: In the initialization part, this version follows mostly
+X * Rick Richardson's version distributed via Usenet, not the
+X * version distributed earlier via floppy disk by Reinhold Weicker.
+X * As a concession to older compilers, names have been made
+X * unique within the first 8 characters.
+X * Inside the measurement loop, this version follows the
+X * version previously distributed by Reinhold Weicker.
+X *
+X * At several places in the benchmark, code has been added,
+X * but within the measurement loop only in branches that
+X * are not executed. The intention is that optimizing compilers
+X * should be prevented from moving code out of the measurement
+X * loop, or from removing code altogether. Since the statements
+X * that are executed within the measurement loop have NOT been
+X * changed, the numbers defining the "Dhrystone distribution"
+X * (distribution of statements, operand types and locality)
+X * still hold. Except for sophisticated optimizing compilers,
+X * execution times for this version should be the same as
+X * for previous versions.
+X *
+X * Since it has proven difficult to subtract the time for the
+X * measurement loop overhead in a correct way, the loop check
+X * has been made a part of the benchmark. This does have
+X * an impact - though a very minor one - on the distribution
+X * statistics which have been updated for this version.
+X *
+X * All changes within the measurement loop are described
+X * and discussed in the companion paper "Rationale for
+X * Dhrystone version 2".
+X *
+X * Because of the self-imposed limitation that the order and
+X * distribution of the executed statements should not be
+X * changed, there are still cases where optimizing compilers
+X * may not generate code for some statements. To a certain
+X * degree, this is unavoidable for small synthetic benchmarks.
+X * Users of the benchmark are advised to check code listings
+X * whether code is generated for all statements of Dhrystone.
+X *
+X * Version 2.1 is identical to version 2.0 distributed via
+X * the UNIX network Usenet in March 1988 except that it corrects
+X * some minor deficiencies that were found by users of version 2.0.
+X * The following corrections have been made in the C version:
+X * - The assignment to Number_Of_Runs was changed
+X * - The constant Too_Small_Time was changed
+X * - An "else" part was added to the "if" statement in Func_3;
+X * for compensation, an "else" part was removed in Proc_3
+X * - Shorter file names are used
+X *
+X ***************************************************************************
+X *
+X * Defines: The following "Defines" are possible:
+X * -DREG=register (default: Not defined)
+X * As an approximation to what an average C programmer
+X * might do, the "register" storage class is applied
+X * (if enabled by -DREG=register)
+X * - for local variables, if they are used (dynamically)
+X * five or more times
+X * - for parameters if they are used (dynamically)
+X * six or more times
+X * Note that an optimal "register" strategy is
+X * compiler-dependent, and that "register" declarations
+X * do not necessarily lead to faster execution.
+X * -DNOSTRUCTASSIGN (default: Not defined)
+X * Define if the C compiler does not support
+X * assignment of structures.
+X * -DNOENUMS (default: Not defined)
+X * Define if the C compiler does not support
+X * enumeration types.
+X * -DTIMES (default)
+X * -DTIME
+X * The "times" function of UNIX (returning process times)
+X * or the "time" function (returning wallclock time)
+X * is used for measurement.
+X * For single user machines, "time ()" is adequate. For
+X * multi-user machines where you cannot get single-user
+X * access, use the "times ()" function. If you have
+X * neither, use a stopwatch in the dead of night.
+X * "printf"s are provided marking the points "Start Timer"
+X * and "Stop Timer". DO NOT use the UNIX "time(1)"
+X * command, as this will measure the total time to
+X * run this program, which will (erroneously) include
+X * the time to allocate storage (malloc) and to perform
+X * the initialization.
+X * -DHZ=nnn
+X * In Berkeley UNIX, the function "times" returns process
+X * time in 1/HZ seconds, with HZ = 60 for most systems.
+X * CHECK YOUR SYSTEM DESCRIPTION BEFORE YOU JUST APPLY
+X * A VALUE.
+X *
+X ***************************************************************************
+X *
+X * Compilation model and measurement (IMPORTANT):
+X *
+X * This C version of Dhrystone consists of three files:
+X * - dhry.h (this file, containing global definitions and comments)
+X * - dhry_1.c (containing the code corresponding to Ada package Pack_1)
+X * - dhry_2.c (containing the code corresponding to Ada package Pack_2)
+X *
+X * The following "ground rules" apply for measurements:
+X * - Separate compilation
+X * - No procedure merging
+X * - Otherwise, compiler optimizations are allowed but should be indicated
+X * - Default results are those without register declarations
+X * See the companion paper "Rationale for Dhrystone Version 2" for a more
+X * detailed discussion of these ground rules.
+X *
+X * For 16-Bit processors (e.g. 80186, 80286), times for all compilation
+X * models ("small", "medium", "large" etc.) should be given if possible,
+X * together with a definition of these models for the compiler system used.
+X *
+X **************************************************************************
+X *
+X * Dhrystone (C version) statistics:
+X *
+X * [Comment from the first distribution, updated for version 2.
+X * Note that because of language differences, the numbers are slightly
+X * different from the Ada version.]
+X *
+X * The following program contains statements of a high level programming
+X * language (here: C) in a distribution considered representative:
+X *
+X * assignments 52 (51.0 %)
+X * control statements 33 (32.4 %)
+X * procedure, function calls 17 (16.7 %)
+X *
+X * 103 statements are dynamically executed. The program is balanced with
+X * respect to the three aspects:
+X *
+X * - statement type
+X * - operand type
+X * - operand locality
+X * operand global, local, parameter, or constant.
+X *
+X * The combination of these three aspects is balanced only approximately.
+X *
+X * 1. Statement Type:
+X * ----------------- number
+X *
+X * V1 = V2 9
+X * (incl. V1 = F(..)
+X * V = Constant 12
+X * Assignment, 7
+X * with array element
+X * Assignment, 6
+X * with record component
+X * --
+X * 34 34
+X *
+X * X = Y +|-|"&&"|"|" Z 5
+X * X = Y +|-|"==" Constant 6
+X * X = X +|- 1 3
+X * X = Y *|/ Z 2
+X * X = Expression, 1
+X * two operators
+X * X = Expression, 1
+X * three operators
+X * --
+X * 18 18
+X *
+X * if .... 14
+X * with "else" 7
+X * without "else" 7
+X * executed 3
+X * not executed 4
+X * for ... 7 | counted every time
+X * while ... 4 | the loop condition
+X * do ... while 1 | is evaluated
+X * switch ... 1
+X * break 1
+X * declaration with 1
+X * initialization
+X * --
+X * 34 34
+X *
+X * P (...) procedure call 11
+X * user procedure 10
+X * library procedure 1
+X * X = F (...)
+X * function call 6
+X * user function 5
+X * library function 1
+X * --
+X * 17 17
+X * ---
+X * 103
+X *
+X * The average number of parameters in procedure or function calls
+X * is 1.82 (not counting the function values as implicit parameters).
+X *
+X *
+X * 2. Operators
+X * ------------
+X * number approximate
+X * percentage
+X *
+X * Arithmetic 32 50.8
+X *
+X * + 21 33.3
+X * - 7 11.1
+X * * 3 4.8
+X * / (int div) 1 1.6
+X *
+X * Comparison 27 42.8
+X *
+X * == 9 14.3
+X * /= 4 6.3
+X * > 1 1.6
+X * < 3 4.8
+X * >= 1 1.6
+X * <= 9 14.3
+X *
+X * Logic 4 6.3
+X *
+X * && (AND-THEN) 1 1.6
+X * | (OR) 1 1.6
+X * ! (NOT) 2 3.2
+X *
+X * -- -----
+X * 63 100.1
+X *
+X *
+X * 3. Operand Type (counted once per operand reference):
+X * ---------------
+X * number approximate
+X * percentage
+X *
+X * Integer 175 72.3 %
+X * Character 45 18.6 %
+X * Pointer 12 5.0 %
+X * String30 6 2.5 %
+X * Array 2 0.8 %
+X * Record 2 0.8 %
+X * --- -------
+X * 242 100.0 %
+X *
+X * When there is an access path leading to the final operand (e.g. a record
+X * component), only the final data type on the access path is counted.
+X *
+X *
+X * 4. Operand Locality:
+X * -------------------
+X * number approximate
+X * percentage
+X *
+X * local variable 114 47.1 %
+X * global variable 22 9.1 %
+X * parameter 45 18.6 %
+X * value 23 9.5 %
+X * reference 22 9.1 %
+X * function result 6 2.5 %
+X * constant 55 22.7 %
+X * --- -------
+X * 242 100.0 %
+X *
+X *
+X * The program does not compute anything meaningful, but it is syntactically
+X * and semantically correct. All variables have a value assigned to them
+X * before they are used as a source operand.
+X *
+X * There has been no explicit effort to account for the effects of a
+X * cache, or to balance the use of long or short displacements for code or
+X * data.
+X *
+X ***************************************************************************
+X */
+X
+X/* Compiler and system dependent definitions: */
+X
+X#ifndef TIME
+X#ifndef TIMES
+X#define TIMES
+X#endif
+X#endif
+X /* Use times(2) time function unless */
+X /* explicitly defined otherwise */
+X
+X#ifdef MSC_CLOCK
+X#undef HZ
+X#undef TIMES
+X#include <time.h>
+X#define HZ CLK_TCK
+X#endif
+X /* Use Microsoft C hi-res clock */
+X
+X#ifdef TIMES
+X#include <sys/types.h>
+X#include <sys/times.h>
+X /* for "times" */
+X#endif
+X
+X#define Mic_secs_Per_Second 1000000.0
+X /* Berkeley UNIX C returns process times in seconds/HZ */
+X
+X#ifdef NOSTRUCTASSIGN
+X#define structassign(d, s) memcpy(&(d), &(s), sizeof(d))
+X#else
+X#define structassign(d, s) d = s
+X#endif
+X
+X#ifdef NOENUM
+X#define Ident_1 0
+X#define Ident_2 1
+X#define Ident_3 2
+X#define Ident_4 3
+X#define Ident_5 4
+X typedef int Enumeration;
+X#else
+X typedef enum {Ident_1, Ident_2, Ident_3, Ident_4, Ident_5}
+X Enumeration;
+X#endif
+X /* for boolean and enumeration types in Ada, Pascal */
+X
+X/* General definitions: */
+X
+X#include <stdio.h>
+X /* for strcpy, strcmp */
+X
+X#define Null 0
+X /* Value of a Null pointer */
+X#define true 1
+X#define false 0
+X
+Xtypedef int One_Thirty;
+Xtypedef int One_Fifty;
+Xtypedef char Capital_Letter;
+Xtypedef int Boolean;
+Xtypedef char Str_30 [31];
+Xtypedef int Arr_1_Dim [50];
+Xtypedef int Arr_2_Dim [50] [50];
+X
+Xtypedef struct record
+X {
+X struct record *Ptr_Comp;
+X Enumeration Discr;
+X union {
+X struct {
+X Enumeration Enum_Comp;
+X int Int_Comp;
+X char Str_Comp [31];
+X } var_1;
+X struct {
+X Enumeration E_Comp_2;
+X char Str_2_Comp [31];
+X } var_2;
+X struct {
+X char Ch_1_Comp;
+X char Ch_2_Comp;
+X } var_3;
+X } variant;
+X } Rec_Type, *Rec_Pointer;
+X
+X
+SHAR_EOF
+fi
+if test -f 'dhry_1.c'
+then
+ echo shar: "will not over-write existing file 'dhry_1.c'"
+else
+sed 's/^X//' << \SHAR_EOF > 'dhry_1.c'
+X/*
+X ****************************************************************************
+X *
+X * "DHRYSTONE" Benchmark Program
+X * -----------------------------
+X *
+X * Version: C, Version 2.1
+X *
+X * File: dhry_1.c (part 2 of 3)
+X *
+X * Date: May 17, 1988
+X *
+X * Author: Reinhold P. Weicker
+X *
+X ****************************************************************************
+X */
+X
+X#include "dhry.h"
+X
+X/* Global Variables: */
+X
+XRec_Pointer Ptr_Glob,
+X Next_Ptr_Glob;
+Xint Int_Glob;
+XBoolean Bool_Glob;
+Xchar Ch_1_Glob,
+X Ch_2_Glob;
+Xint Arr_1_Glob [50];
+Xint Arr_2_Glob [50] [50];
+X
+Xextern char *malloc ();
+XEnumeration Func_1 ();
+X /* forward declaration necessary since Enumeration may not simply be int */
+X
+X#ifndef REG
+X Boolean Reg = false;
+X#define REG
+X /* REG becomes defined as empty */
+X /* i.e. no register variables */
+X#else
+X Boolean Reg = true;
+X#endif
+X
+X/* variables for time measurement: */
+X
+X#ifdef TIMES
+Xstruct tms time_info;
+Xextern int times ();
+X /* see library function "times" */
+X#define Too_Small_Time (2*HZ)
+X /* Measurements should last at least about 2 seconds */
+X#endif
+X#ifdef TIME
+Xextern long time();
+X /* see library function "time" */
+X#define Too_Small_Time 2
+X /* Measurements should last at least 2 seconds */
+X#endif
+X#ifdef MSC_CLOCK
+Xextern clock_t clock();
+X#define Too_Small_Time (2*HZ)
+X#endif
+X
+Xlong Begin_Time,
+X End_Time,
+X User_Time;
+Xfloat Microseconds,
+X Dhrystones_Per_Second;
+X
+X/* end of variables for time measurement */
+X
+X
+Xmain ()
+X/*****/
+X
+X /* main program, corresponds to procedures */
+X /* Main and Proc_0 in the Ada version */
+X{
+X One_Fifty Int_1_Loc;
+X REG One_Fifty Int_2_Loc;
+X One_Fifty Int_3_Loc;
+X REG char Ch_Index;
+X Enumeration Enum_Loc;
+X Str_30 Str_1_Loc;
+X Str_30 Str_2_Loc;
+X REG int Run_Index;
+X REG int Number_Of_Runs;
+X
+X /* Initializations */
+X
+X Next_Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
+X Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
+X
+X Ptr_Glob->Ptr_Comp = Next_Ptr_Glob;
+X Ptr_Glob->Discr = Ident_1;
+X Ptr_Glob->variant.var_1.Enum_Comp = Ident_3;
+X Ptr_Glob->variant.var_1.Int_Comp = 40;
+X strcpy (Ptr_Glob->variant.var_1.Str_Comp,
+X "DHRYSTONE PROGRAM, SOME STRING");
+X strcpy (Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING");
+X
+X Arr_2_Glob [8][7] = 10;
+X /* Was missing in published program. Without this statement, */
+X /* Arr_2_Glob [8][7] would have an undefined value. */
+X /* Warning: With 16-Bit processors and Number_Of_Runs > 32000, */
+X /* overflow may occur for this array element. */
+X
+X printf ("\n");
+X printf ("Dhrystone Benchmark, Version 2.1 (Language: C)\n");
+X printf ("\n");
+X if (Reg)
+X {
+X printf ("Program compiled with 'register' attribute\n");
+X printf ("\n");
+X }
+X else
+X {
+X printf ("Program compiled without 'register' attribute\n");
+X printf ("\n");
+X }
+X printf ("Please give the number of runs through the benchmark: ");
+X {
+X int n;
+X scanf ("%d", &n);
+X Number_Of_Runs = n;
+X }
+X printf ("\n");
+X
+X printf ("Execution starts, %d runs through Dhrystone\n", Number_Of_Runs);
+X
+X /***************/
+X /* Start timer */
+X /***************/
+X
+X#ifdef TIMES
+X times (&time_info);
+X Begin_Time = (long) time_info.tms_utime;
+X#endif
+X#ifdef TIME
+X Begin_Time = time ( (long *) 0);
+X#endif
+X#ifdef MSC_CLOCK
+X Begin_Time = clock();
+X#endif
+X
+X for (Run_Index = 1; Run_Index <= Number_Of_Runs; ++Run_Index)
+X {
+X
+X Proc_5();
+X Proc_4();
+X /* Ch_1_Glob == 'A', Ch_2_Glob == 'B', Bool_Glob == true */
+X Int_1_Loc = 2;
+X Int_2_Loc = 3;
+X strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING");
+X Enum_Loc = Ident_2;
+X Bool_Glob = ! Func_2 (Str_1_Loc, Str_2_Loc);
+X /* Bool_Glob == 1 */
+X while (Int_1_Loc < Int_2_Loc) /* loop body executed once */
+X {
+X Int_3_Loc = 5 * Int_1_Loc - Int_2_Loc;
+X /* Int_3_Loc == 7 */
+X Proc_7 (Int_1_Loc, Int_2_Loc, &Int_3_Loc);
+X /* Int_3_Loc == 7 */
+X Int_1_Loc += 1;
+X } /* while */
+X /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
+X Proc_8 (Arr_1_Glob, Arr_2_Glob, Int_1_Loc, Int_3_Loc);
+X /* Int_Glob == 5 */
+X Proc_1 (Ptr_Glob);
+X for (Ch_Index = 'A'; Ch_Index <= Ch_2_Glob; ++Ch_Index)
+X /* loop body executed twice */
+X {
+X if (Enum_Loc == Func_1 (Ch_Index, 'C'))
+X /* then, not executed */
+X {
+X Proc_6 (Ident_1, &Enum_Loc);
+X strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 3'RD STRING");
+X Int_2_Loc = Run_Index;
+X Int_Glob = Run_Index;
+X }
+X }
+X /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
+X Int_2_Loc = Int_2_Loc * Int_1_Loc;
+X Int_1_Loc = Int_2_Loc / Int_3_Loc;
+X Int_2_Loc = 7 * (Int_2_Loc - Int_3_Loc) - Int_1_Loc;
+X /* Int_1_Loc == 1, Int_2_Loc == 13, Int_3_Loc == 7 */
+X Proc_2 (&Int_1_Loc);
+X /* Int_1_Loc == 5 */
+X
+X } /* loop "for Run_Index" */
+X
+X /**************/
+X /* Stop timer */
+X /**************/
+X
+X#ifdef TIMES
+X times (&time_info);
+X End_Time = (long) time_info.tms_utime;
+X#endif
+X#ifdef TIME
+X End_Time = time ( (long *) 0);
+X#endif
+X#ifdef MSC_CLOCK
+X End_Time = clock();
+X#endif
+X
+X printf ("Execution ends\n");
+X printf ("\n");
+X printf ("Final values of the variables used in the benchmark:\n");
+X printf ("\n");
+X printf ("Int_Glob: %d\n", Int_Glob);
+X printf (" should be: %d\n", 5);
+X printf ("Bool_Glob: %d\n", Bool_Glob);
+X printf (" should be: %d\n", 1);
+X printf ("Ch_1_Glob: %c\n", Ch_1_Glob);
+X printf (" should be: %c\n", 'A');
+X printf ("Ch_2_Glob: %c\n", Ch_2_Glob);
+X printf (" should be: %c\n", 'B');
+X printf ("Arr_1_Glob[8]: %d\n", Arr_1_Glob[8]);
+X printf (" should be: %d\n", 7);
+X printf ("Arr_2_Glob[8][7]: %d\n", Arr_2_Glob[8][7]);
+X printf (" should be: Number_Of_Runs + 10\n");
+X printf ("Ptr_Glob->\n");
+X printf (" Ptr_Comp: %d\n", (int) Ptr_Glob->Ptr_Comp);
+X printf (" should be: (implementation-dependent)\n");
+X printf (" Discr: %d\n", Ptr_Glob->Discr);
+X printf (" should be: %d\n", 0);
+X printf (" Enum_Comp: %d\n", Ptr_Glob->variant.var_1.Enum_Comp);
+X printf (" should be: %d\n", 2);
+X printf (" Int_Comp: %d\n", Ptr_Glob->variant.var_1.Int_Comp);
+X printf (" should be: %d\n", 17);
+X printf (" Str_Comp: %s\n", Ptr_Glob->variant.var_1.Str_Comp);
+X printf (" should be: DHRYSTONE PROGRAM, SOME STRING\n");
+X printf ("Next_Ptr_Glob->\n");
+X printf (" Ptr_Comp: %d\n", (int) Next_Ptr_Glob->Ptr_Comp);
+X printf (" should be: (implementation-dependent), same as above\n");
+X printf (" Discr: %d\n", Next_Ptr_Glob->Discr);
+X printf (" should be: %d\n", 0);
+X printf (" Enum_Comp: %d\n", Next_Ptr_Glob->variant.var_1.Enum_Comp);
+X printf (" should be: %d\n", 1);
+X printf (" Int_Comp: %d\n", Next_Ptr_Glob->variant.var_1.Int_Comp);
+X printf (" should be: %d\n", 18);
+X printf (" Str_Comp: %s\n",
+X Next_Ptr_Glob->variant.var_1.Str_Comp);
+X printf (" should be: DHRYSTONE PROGRAM, SOME STRING\n");
+X printf ("Int_1_Loc: %d\n", Int_1_Loc);
+X printf (" should be: %d\n", 5);
+X printf ("Int_2_Loc: %d\n", Int_2_Loc);
+X printf (" should be: %d\n", 13);
+X printf ("Int_3_Loc: %d\n", Int_3_Loc);
+X printf (" should be: %d\n", 7);
+X printf ("Enum_Loc: %d\n", Enum_Loc);
+X printf (" should be: %d\n", 1);
+X printf ("Str_1_Loc: %s\n", Str_1_Loc);
+X printf (" should be: DHRYSTONE PROGRAM, 1'ST STRING\n");
+X printf ("Str_2_Loc: %s\n", Str_2_Loc);
+X printf (" should be: DHRYSTONE PROGRAM, 2'ND STRING\n");
+X printf ("\n");
+X
+X User_Time = End_Time - Begin_Time;
+X
+X if (User_Time < Too_Small_Time)
+X {
+X printf ("Measured time too small to obtain meaningful results\n");
+X printf ("Please increase number of runs\n");
+X printf ("\n");
+X }
+X else
+X {
+X#ifdef TIME
+X Microseconds = (float) User_Time * Mic_secs_Per_Second
+X / (float) Number_Of_Runs;
+X Dhrystones_Per_Second = (float) Number_Of_Runs / (float) User_Time;
+X#else
+X Microseconds = (float) User_Time * Mic_secs_Per_Second
+X / ((float) HZ * ((float) Number_Of_Runs));
+X Dhrystones_Per_Second = ((float) HZ * (float) Number_Of_Runs)
+X / (float) User_Time;
+X#endif
+X printf ("Microseconds for one run through Dhrystone: ");
+X printf ("%6.1f \n", Microseconds);
+X printf ("Dhrystones per Second: ");
+X printf ("%6.1f \n", Dhrystones_Per_Second);
+X printf ("\n");
+X }
+X
+X}
+X
+X
+XProc_1 (Ptr_Val_Par)
+X/******************/
+X
+XREG Rec_Pointer Ptr_Val_Par;
+X /* executed once */
+X{
+X REG Rec_Pointer Next_Record = Ptr_Val_Par->Ptr_Comp;
+X /* == Ptr_Glob_Next */
+X /* Local variable, initialized with Ptr_Val_Par->Ptr_Comp, */
+X /* corresponds to "rename" in Ada, "with" in Pascal */
+X
+X structassign (*Ptr_Val_Par->Ptr_Comp, *Ptr_Glob);
+X Ptr_Val_Par->variant.var_1.Int_Comp = 5;
+X Next_Record->variant.var_1.Int_Comp
+X = Ptr_Val_Par->variant.var_1.Int_Comp;
+X Next_Record->Ptr_Comp = Ptr_Val_Par->Ptr_Comp;
+X Proc_3 (&Next_Record->Ptr_Comp);
+X /* Ptr_Val_Par->Ptr_Comp->Ptr_Comp
+X == Ptr_Glob->Ptr_Comp */
+X if (Next_Record->Discr == Ident_1)
+X /* then, executed */
+X {
+X Next_Record->variant.var_1.Int_Comp = 6;
+X Proc_6 (Ptr_Val_Par->variant.var_1.Enum_Comp,
+X &Next_Record->variant.var_1.Enum_Comp);
+X Next_Record->Ptr_Comp = Ptr_Glob->Ptr_Comp;
+X Proc_7 (Next_Record->variant.var_1.Int_Comp, 10,
+X &Next_Record->variant.var_1.Int_Comp);
+X }
+X else /* not executed */
+X structassign (*Ptr_Val_Par, *Ptr_Val_Par->Ptr_Comp);
+X} /* Proc_1 */
+X
+X
+XProc_2 (Int_Par_Ref)
+X/******************/
+X /* executed once */
+X /* *Int_Par_Ref == 1, becomes 4 */
+X
+XOne_Fifty *Int_Par_Ref;
+X{
+X One_Fifty Int_Loc;
+X Enumeration Enum_Loc;
+X
+X Int_Loc = *Int_Par_Ref + 10;
+X do /* executed once */
+X if (Ch_1_Glob == 'A')
+X /* then, executed */
+X {
+X Int_Loc -= 1;
+X *Int_Par_Ref = Int_Loc - Int_Glob;
+X Enum_Loc = Ident_1;
+X } /* if */
+X while (Enum_Loc != Ident_1); /* true */
+X} /* Proc_2 */
+X
+X
+XProc_3 (Ptr_Ref_Par)
+X/******************/
+X /* executed once */
+X /* Ptr_Ref_Par becomes Ptr_Glob */
+X
+XRec_Pointer *Ptr_Ref_Par;
+X
+X{
+X if (Ptr_Glob != Null)
+X /* then, executed */
+X *Ptr_Ref_Par = Ptr_Glob->Ptr_Comp;
+X Proc_7 (10, Int_Glob, &Ptr_Glob->variant.var_1.Int_Comp);
+X} /* Proc_3 */
+X
+X
+XProc_4 () /* without parameters */
+X/*******/
+X /* executed once */
+X{
+X Boolean Bool_Loc;
+X
+X Bool_Loc = Ch_1_Glob == 'A';
+X Bool_Glob = Bool_Loc | Bool_Glob;
+X Ch_2_Glob = 'B';
+X} /* Proc_4 */
+X
+X
+XProc_5 () /* without parameters */
+X/*******/
+X /* executed once */
+X{
+X Ch_1_Glob = 'A';
+X Bool_Glob = false;
+X} /* Proc_5 */
+X
+X
+X /* Procedure for the assignment of structures, */
+X /* if the C compiler doesn't support this feature */
+X#ifdef NOSTRUCTASSIGN
+Xmemcpy (d, s, l)
+Xregister char *d;
+Xregister char *s;
+Xregister int l;
+X{
+X while (l--) *d++ = *s++;
+X}
+X#endif
+X
+X
+SHAR_EOF
+fi
+if test -f 'dhry_2.c'
+then
+ echo shar: "will not over-write existing file 'dhry_2.c'"
+else
+sed 's/^X//' << \SHAR_EOF > 'dhry_2.c'
+X/*
+X ****************************************************************************
+X *
+X * "DHRYSTONE" Benchmark Program
+X * -----------------------------
+X *
+X * Version: C, Version 2.1
+X *
+X * File: dhry_2.c (part 3 of 3)
+X *
+X * Date: May 17, 1988
+X *
+X * Author: Reinhold P. Weicker
+X *
+X ****************************************************************************
+X */
+X
+X#include "dhry.h"
+X
+X#ifndef REG
+X#define REG
+X /* REG becomes defined as empty */
+X /* i.e. no register variables */
+X#endif
+X
+Xextern int Int_Glob;
+Xextern char Ch_1_Glob;
+X
+X
+XProc_6 (Enum_Val_Par, Enum_Ref_Par)
+X/*********************************/
+X /* executed once */
+X /* Enum_Val_Par == Ident_3, Enum_Ref_Par becomes Ident_2 */
+X
+XEnumeration Enum_Val_Par;
+XEnumeration *Enum_Ref_Par;
+X{
+X *Enum_Ref_Par = Enum_Val_Par;
+X if (! Func_3 (Enum_Val_Par))
+X /* then, not executed */
+X *Enum_Ref_Par = Ident_4;
+X switch (Enum_Val_Par)
+X {
+X case Ident_1:
+X *Enum_Ref_Par = Ident_1;
+X break;
+X case Ident_2:
+X if (Int_Glob > 100)
+X /* then */
+X *Enum_Ref_Par = Ident_1;
+X else *Enum_Ref_Par = Ident_4;
+X break;
+X case Ident_3: /* executed */
+X *Enum_Ref_Par = Ident_2;
+X break;
+X case Ident_4: break;
+X case Ident_5:
+X *Enum_Ref_Par = Ident_3;
+X break;
+X } /* switch */
+X} /* Proc_6 */
+X
+X
+XProc_7 (Int_1_Par_Val, Int_2_Par_Val, Int_Par_Ref)
+X/**********************************************/
+X /* executed three times */
+X /* first call: Int_1_Par_Val == 2, Int_2_Par_Val == 3, */
+X /* Int_Par_Ref becomes 7 */
+X /* second call: Int_1_Par_Val == 10, Int_2_Par_Val == 5, */
+X /* Int_Par_Ref becomes 17 */
+X /* third call: Int_1_Par_Val == 6, Int_2_Par_Val == 10, */
+X /* Int_Par_Ref becomes 18 */
+XOne_Fifty Int_1_Par_Val;
+XOne_Fifty Int_2_Par_Val;
+XOne_Fifty *Int_Par_Ref;
+X{
+X One_Fifty Int_Loc;
+X
+X Int_Loc = Int_1_Par_Val + 2;
+X *Int_Par_Ref = Int_2_Par_Val + Int_Loc;
+X} /* Proc_7 */
+X
+X
+XProc_8 (Arr_1_Par_Ref, Arr_2_Par_Ref, Int_1_Par_Val, Int_2_Par_Val)
+X/*********************************************************************/
+X /* executed once */
+X /* Int_Par_Val_1 == 3 */
+X /* Int_Par_Val_2 == 7 */
+XArr_1_Dim Arr_1_Par_Ref;
+XArr_2_Dim Arr_2_Par_Ref;
+Xint Int_1_Par_Val;
+Xint Int_2_Par_Val;
+X{
+X REG One_Fifty Int_Index;
+X REG One_Fifty Int_Loc;
+X
+X Int_Loc = Int_1_Par_Val + 5;
+X Arr_1_Par_Ref [Int_Loc] = Int_2_Par_Val;
+X Arr_1_Par_Ref [Int_Loc+1] = Arr_1_Par_Ref [Int_Loc];
+X Arr_1_Par_Ref [Int_Loc+30] = Int_Loc;
+X for (Int_Index = Int_Loc; Int_Index <= Int_Loc+1; ++Int_Index)
+X Arr_2_Par_Ref [Int_Loc] [Int_Index] = Int_Loc;
+X Arr_2_Par_Ref [Int_Loc] [Int_Loc-1] += 1;
+X Arr_2_Par_Ref [Int_Loc+20] [Int_Loc] = Arr_1_Par_Ref [Int_Loc];
+X Int_Glob = 5;
+X} /* Proc_8 */
+X
+X
+XEnumeration Func_1 (Ch_1_Par_Val, Ch_2_Par_Val)
+X/*************************************************/
+X /* executed three times */
+X /* first call: Ch_1_Par_Val == 'H', Ch_2_Par_Val == 'R' */
+X /* second call: Ch_1_Par_Val == 'A', Ch_2_Par_Val == 'C' */
+X /* third call: Ch_1_Par_Val == 'B', Ch_2_Par_Val == 'C' */
+X
+XCapital_Letter Ch_1_Par_Val;
+XCapital_Letter Ch_2_Par_Val;
+X{
+X Capital_Letter Ch_1_Loc;
+X Capital_Letter Ch_2_Loc;
+X
+X Ch_1_Loc = Ch_1_Par_Val;
+X Ch_2_Loc = Ch_1_Loc;
+X if (Ch_2_Loc != Ch_2_Par_Val)
+X /* then, executed */
+X return (Ident_1);
+X else /* not executed */
+X {
+X Ch_1_Glob = Ch_1_Loc;
+X return (Ident_2);
+X }
+X} /* Func_1 */
+X
+X
+XBoolean Func_2 (Str_1_Par_Ref, Str_2_Par_Ref)
+X/*************************************************/
+X /* executed once */
+X /* Str_1_Par_Ref == "DHRYSTONE PROGRAM, 1'ST STRING" */
+X /* Str_2_Par_Ref == "DHRYSTONE PROGRAM, 2'ND STRING" */
+X
+XStr_30 Str_1_Par_Ref;
+XStr_30 Str_2_Par_Ref;
+X{
+X REG One_Thirty Int_Loc;
+X Capital_Letter Ch_Loc;
+X
+X Int_Loc = 2;
+X while (Int_Loc <= 2) /* loop body executed once */
+X if (Func_1 (Str_1_Par_Ref[Int_Loc],
+X Str_2_Par_Ref[Int_Loc+1]) == Ident_1)
+X /* then, executed */
+X {
+X Ch_Loc = 'A';
+X Int_Loc += 1;
+X } /* if, while */
+X if (Ch_Loc >= 'W' && Ch_Loc < 'Z')
+X /* then, not executed */
+X Int_Loc = 7;
+X if (Ch_Loc == 'R')
+X /* then, not executed */
+X return (true);
+X else /* executed */
+X {
+X if (strcmp (Str_1_Par_Ref, Str_2_Par_Ref) > 0)
+X /* then, not executed */
+X {
+X Int_Loc += 7;
+X Int_Glob = Int_Loc;
+X return (true);
+X }
+X else /* executed */
+X return (false);
+X } /* if Ch_Loc */
+X} /* Func_2 */
+X
+X
+XBoolean Func_3 (Enum_Par_Val)
+X/***************************/
+X /* executed once */
+X /* Enum_Par_Val == Ident_3 */
+XEnumeration Enum_Par_Val;
+X{
+X Enumeration Enum_Loc;
+X
+X Enum_Loc = Enum_Par_Val;
+X if (Enum_Loc == Ident_3)
+X /* then, executed */
+X return (true);
+X else /* not executed */
+X return (false);
+X} /* Func_3 */
+X
+SHAR_EOF
+fi
+exit 0
+# End of shell archive
diff --git a/hostsidetests/sustainedperf/dhrystone/LICENSE.TXT b/hostsidetests/sustainedperf/dhrystone/LICENSE.TXT
new file mode 100644
index 0000000..84090c0
--- /dev/null
+++ b/hostsidetests/sustainedperf/dhrystone/LICENSE.TXT
@@ -0,0 +1,70 @@
+==============================================================================
+LLVM Release License
+==============================================================================
+University of Illinois/NCSA
+Open Source License
+
+Copyright (c) 2003-2015 University of Illinois at Urbana-Champaign.
+All rights reserved.
+
+Developed by:
+
+ LLVM Team
+
+ University of Illinois at Urbana-Champaign
+
+ http://llvm.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal with
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimers.
+
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimers in the
+ documentation and/or other materials provided with the distribution.
+
+ * Neither the names of the LLVM Team, University of Illinois at
+ Urbana-Champaign, nor the names of its contributors may be used to
+ endorse or promote products derived from this Software without specific
+ prior written permission.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
+SOFTWARE.
+
+==============================================================================
+Copyrights and Licenses for Third Party Software Distributed with LLVM:
+==============================================================================
+The LLVM software contains code written by third parties. Such software will
+have its own individual LICENSE.TXT file in the directory in which it appears.
+This file will describe the copyrights, license, and restrictions which apply
+to that code.
+
+The disclaimer of warranty in the University of Illinois Open Source License
+applies to all code in the LLVM Distribution, and nothing in any of the
+other licenses gives permission to use the names of the LLVM Team or the
+University of Illinois to endorse or promote products derived from this
+Software.
+
+The following pieces of software have additional or alternate copyrights,
+licenses, and/or restrictions:
+
+Program Directory
+------- ---------
+Autoconf llvm/autoconf
+ llvm/projects/ModuleMaker/autoconf
+Google Test llvm/utils/unittest/googletest
+OpenBSD regex llvm/lib/Support/{reg*, COPYRIGHT.regex}
+pyyaml tests llvm/test/YAMLParser/{*.data, LICENSE.TXT}
+ARM contributions llvm/lib/Target/ARM/LICENSE.TXT
+md5 contributions llvm/lib/Support/MD5.cpp llvm/include/llvm/Support/MD5.h
diff --git a/hostsidetests/sustainedperf/dhrystone/Rationale b/hostsidetests/sustainedperf/dhrystone/Rationale
new file mode 100644
index 0000000..0d93e10
--- /dev/null
+++ b/hostsidetests/sustainedperf/dhrystone/Rationale
@@ -0,0 +1,360 @@
+Dhrystone Benchmark: Rationale for Version 2 and Measurement Rules
+
+ Reinhold P. Weicker
+ Siemens AG, E STE 35
+ Postfach 3240
+ D-8520 Erlangen
+ Germany (West)
+
+
+
+
+The Dhrystone benchmark program [1] has become a popular benchmark for
+CPU/compiler performance measurement, in particular in the area of
+minicomputers, workstations, PC's and microprocesors. It apparently
+satisfies a need for an easy-to-use integer benchmark; it gives a first
+performance indication which is more meaningful than MIPS numbers
+which, in their literal meaning (million instructions per second),
+cannot be used across different instruction sets (e.g. RISC vs. CISC).
+With the increasing use of the benchmark, it seems necessary to
+reconsider the benchmark and to check whether it can still fulfill this
+function. Version 2 of Dhrystone is the result of such a re-
+evaluation, it has been made for two reasons:
+
+o Dhrystone has been published in Ada [1], and Versions in Ada, Pascal
+ and C have been distributed by Reinhold Weicker via floppy disk.
+ However, the version that was used most often for benchmarking has
+ been the version made by Rick Richardson by another translation from
+ the Ada version into the C programming language, this has been the
+ version distributed via the UNIX network Usenet [2].
+
+ There is an obvious need for a common C version of Dhrystone, since C
+ is at present the most popular system programming language for the
+ class of systems (microcomputers, minicomputers, workstations) where
+ Dhrystone is used most. There should be, as far as possible, only
+ one C version of Dhrystone such that results can be compared without
+ restrictions. In the past, the C versions distributed by Rick
+ Richardson (Version 1.1) and by Reinhold Weicker had small (though
+ not significant) differences.
+
+ Together with the new C version, the Ada and Pascal versions have
+ been updated as well.
+
+o As far as it is possible without changes to the Dhrystone statistics,
+ optimizing compilers should be prevented from removing significant
+ statements. It has turned out in the past that optimizing compilers
+ suppressed code generation for too many statements (by "dead code
+ removal" or "dead variable elimination"). This has lead to the
+ danger that benchmarking results obtained by a naive application of
+ Dhrystone - without inspection of the code that was generated - could
+ become meaningless.
+
+The overall policiy for version 2 has been that the distribution of
+statements, operand types and operand locality described in [1] should
+remain unchanged as much as possible. (Very few changes were
+necessary; their impact should be negligible.) Also, the order of
+statements should remain unchanged. Although I am aware of some
+critical remarks on the benchmark - I agree with several of them - and
+know some suggestions for improvement, I didn't want to change the
+benchmark into something different from what has become known as
+"Dhrystone"; the confusion generated by such a change would probably
+outweight the benefits. If I were to write a new benchmark program, I
+wouldn't give it the name "Dhrystone" since this denotes the program
+published in [1]. However, I do recognize the need for a larger number
+of representative programs that can be used as benchmarks; users should
+always be encouraged to use more than just one benchmark.
+
+The new versions (version 2.1 for C, Pascal and Ada) will be
+distributed as widely as possible. (Version 2.1 differs from version
+2.0 distributed via the UNIX Network Usenet in March 1988 only in a few
+corrections for minor deficiencies found by users of version 2.0.)
+Readers who want to use the benchmark for their own measurements can
+obtain a copy in machine-readable form on floppy disk (MS-DOS or XENIX
+format) from the author.
+
+
+In general, version 2 follows - in the parts that are significant for
+performance measurement, i.e. within the measurement loop - the
+published (Ada) version and the C versions previously distributed.
+Where the versions distributed by Rick Richardson [2] and Reinhold
+Weicker have been different, it follows the version distributed by
+Reinhold Weicker. (However, the differences have been so small that
+their impact on execution time in all likelihood has been negligible.)
+The initialization and UNIX instrumentation part - which had been
+omitted in [1] - follows mostly the ideas of Rick Richardson [2].
+However, any changes in the initialization part and in the printing of
+the result have no impact on performance measurement since they are
+outside the measaurement loop. As a concession to older compilers,
+names have been made unique within the first 8 characters for the C
+version.
+
+The original publication of Dhrystone did not contain any statements
+for time measurement since they are necessarily system-dependent.
+However, it turned out that it is not enough just to inclose the main
+procedure of Dhrystone in a loop and to measure the execution time. If
+the variables that are computed are not used somehow, there is the
+danger that the compiler considers them as "dead variables" and
+suppresses code generation for a part of the statements. Therefore in
+version 2 all variables of "main" are printed at the end of the
+program. This also permits some plausibility control for correct
+execution of the benchmark.
+
+At several places in the benchmark, code has been added, but only in
+branches that are not executed. The intention is that optimizing
+compilers should be prevented from moving code out of the measurement
+loop, or from removing code altogether. Statements that are executed
+have been changed in very few places only. In these cases, only the
+role of some operands has been changed, and it was made sure that the
+numbers defining the "Dhrystone distribution" (distribution of
+statements, operand types and locality) still hold as much as possible.
+Except for sophisticated optimizing compilers, execution times for
+version 2.1 should be the same as for previous versions.
+
+Because of the self-imposed limitation that the order and distribution
+of the executed statements should not be changed, there are still cases
+where optimizing compilers may not generate code for some statements.
+To a certain degree, this is unavoidable for small synthetic
+benchmarks. Users of the benchmark are advised to check code listings
+whether code is generated for all statements of Dhrystone.
+
+Contrary to the suggestion in the published paper and its realization
+in the versions previously distributed, no attempt has been made to
+subtract the time for the measurement loop overhead. (This calculation
+has proven difficult to implement in a correct way, and its omission
+makes the program simpler.) However, since the loop check is now part
+of the benchmark, this does have an impact - though a very minor one -
+on the distribution statistics which have been updated for this
+version.
+
+
+In this section, all changes are described that affect the measurement
+loop and that are not just renamings of variables. All remarks refer to
+the C version; the other language versions have been updated similarly.
+
+In addition to adding the measurement loop and the printout statements,
+changes have been made at the following places:
+
+o In procedure "main", three statements have been added in the non-
+ executed "then" part of the statement
+ if (Enum_Loc == Func_1 (Ch_Index, 'C'))
+ they are
+ strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 3'RD STRING");
+ Int_2_Loc = Run_Index;
+ Int_Glob = Run_Index;
+ The string assignment prevents movement of the preceding assignment
+ to Str_2_Loc (5'th statement of "main") out of the measurement loop
+ (This probably will not happen for the C version, but it did happen
+ with another language and compiler.) The assignment to Int_2_Loc
+ prevents value propagation for Int_2_Loc, and the assignment to
+ Int_Glob makes the value of Int_Glob possibly dependent from the
+ value of Run_Index.
+
+o In the three arithmetic computations at the end of the measurement
+ loop in "main ", the role of some variables has been exchanged, to
+ prevent the division from just cancelling out the multiplication as
+ it was in [1]. A very smart compiler might have recognized this and
+ suppressed code generation for the division.
+
+o For Proc_2, no code has been changed, but the values of the actual
+ parameter have changed due to changes in "main".
+
+o In Proc_4, the second assignment has been changed from
+ Bool_Loc = Bool_Loc | Bool_Glob;
+ to
+ Bool_Glob = Bool_Loc | Bool_Glob;
+ It now assigns a value to a global variable instead of a local
+ variable (Bool_Loc); Bool_Loc would be a "dead variable" which is not
+ used afterwards.
+
+o In Func_1, the statement
+ Ch_1_Glob = Ch_1_Loc;
+ was added in the non-executed "else" part of the "if" statement, to
+ prevent the suppression of code generation for the assignment to
+ Ch_1_Loc.
+
+o In Func_2, the second character comparison statement has been changed
+ to
+ if (Ch_Loc == 'R')
+ ('R' instead of 'X') because a comparison with 'X' is implied in the
+ preceding "if" statement.
+
+ Also in Func_2, the statement
+ Int_Glob = Int_Loc;
+ has been added in the non-executed part of the last "if" statement,
+ in order to prevent Int_Loc from becoming a dead variable.
+
+o In Func_3, a non-executed "else" part has been added to the "if"
+ statement. While the program would not be incorrect without this
+ "else" part, it is considered bad programming practice if a function
+ can be left without a return value.
+
+ To compensate for this change, the (non-executed) "else" part in the
+ "if" statement of Proc_3 was removed.
+
+The distribution statistics have been changed only by the addition of
+the measurement loop iteration (1 additional statement, 4 additional
+local integer operands) and by the change in Proc_4 (one operand
+changed from local to global). The distribution statistics in the
+comment headers have been updated accordingly.
+
+
+The string operations (string assignment and string comparison) have
+not been changed, to keep the program consistent with the original
+version.
+
+There has been some concern that the string operations are over-
+represented in the program, and that execution time is dominated by
+these operations. This was true in particular when optimizing
+compilers removed too much code in the main part of the program, this
+should have been mitigated in version 2.
+
+It should be noted that this is a language-dependent issue: Dhrystone
+was first published in Ada, and with Ada or Pascal semantics, the time
+spent in the string operations is, at least in all implementations
+known to me, considerably smaller. In Ada and Pascal, assignment and
+comparison of strings are operators defined in the language, and the
+upper bounds of the strings occuring in Dhrystone are part of the type
+information known at compilation time. The compilers can therefore
+generate efficient inline code. In C, string assignemt and comparisons
+are not part of the language, so the string operations must be
+expressed in terms of the C library functions "strcpy" and "strcmp".
+(ANSI C allows an implementation to use inline code for these
+functions.) In addition to the overhead caused by additional function
+calls, these functions are defined for null-terminated strings where
+the length of the strings is not known at compilation time; the
+function has to check every byte for the termination condition (the
+null byte).
+
+Obviously, a C library which includes efficiently coded "strcpy" and
+"strcmp" functions helps to obtain good Dhrystone results. However, I
+don't think that this is unfair since string functions do occur quite
+frequently in real programs (editors, command interpreters, etc.). If
+the strings functions are implemented efficiently, this helps real
+programs as well as benchmark programs.
+
+I admit that the string comparison in Dhrystone terminates later (after
+scanning 20 characters) than most string comparisons in real programs.
+For consistency with the original benchmark, I didn't change the
+program despite this weakness.
+
+
+When Dhrystone is used, the following "ground rules" apply:
+
+o Separate compilation (Ada and C versions)
+
+ As mentioned in [1], Dhrystone was written to reflect actual
+ programming practice in systems programming. The division into
+ several compilation units (5 in the Ada version, 2 in the C version)
+ is intended, as is the distribution of inter-module and intra-module
+ subprogram calls. Although on many systems there will be no
+ difference in execution time to a Dhrystone version where all
+ compilation units are merged into one file, the rule is that separate
+ compilation should be used. The intention is that real programming
+ practice, where programs consist of several independently compiled
+ units, should be reflected. This also has implies that the compiler,
+ while compiling one unit, has no information about the use of
+ variables, register allocation etc. occuring in other compilation
+ units. Although in real life compilation units will probably be
+ larger, the intention is that these effects of separate compilation
+ are modeled in Dhrystone.
+
+ A few language systems have post-linkage optimization available
+ (e.g., final register allocation is performed after linkage). This
+ is a borderline case: Post-linkage optimization involves additional
+ program preparation time (although not as much as compilation in one
+ unit) which may prevent its general use in practical programming. I
+ think that since it defeats the intentions given above, it should not
+ be used for Dhrystone.
+
+ Unfortunately, ISO/ANSI Pascal does not contain language features for
+ separate compilation. Although most commercial Pascal compilers
+ provide separate compilation in some way, we cannot use it for
+ Dhrystone since such a version would not be portable. Therefore, no
+ attempt has been made to provide a Pascal version with several
+ compilation units.
+
+o No procedure merging
+
+ Although Dhrystone contains some very short procedures where
+ execution would benefit from procedure merging (inlining, macro
+ expansion of procedures), procedure merging is not to be used. The
+ reason is that the percentage of procedure and function calls is part
+ of the "Dhrystone distribution" of statements contained in [1]. This
+ restriction does not hold for the string functions of the C version
+ since ANSI C allows an implementation to use inline code for these
+ functions.
+
+
+
+o Other optimizations are allowed, but they should be indicated
+
+ It is often hard to draw an exact line between "normal code
+ generation" and "optimization" in compilers: Some compilers perform
+ operations by default that are invoked in other compilers only when
+ optimization is explicitly requested. Also, we cannot avoid that in
+ benchmarking people try to achieve results that look as good as
+ possible. Therefore, optimizations performed by compilers - other
+ than those listed above - are not forbidden when Dhrystone execution
+ times are measured. Dhrystone is not intended to be non-optimizable
+ but is intended to be similarly optimizable as normal programs. For
+ example, there are several places in Dhrystone where performance
+ benefits from optimizations like common subexpression elimination,
+ value propagation etc., but normal programs usually also benefit from
+ these optimizations. Therefore, no effort was made to artificially
+ prevent such optimizations. However, measurement reports should
+ indicate which compiler optimization levels have been used, and
+ reporting results with different levels of compiler optimization for
+ the same hardware is encouraged.
+
+o Default results are those without "register" declarations (C version)
+
+ When Dhrystone results are quoted without additional qualification,
+ they should be understood as results obtained without use of the
+ "register" attribute. Good compilers should be able to make good use
+ of registers even without explicit register declarations ([3], p.
+ 193).
+
+Of course, for experimental purposes, post-linkage optimization,
+procedure merging and/or compilation in one unit can be done to
+determine their effects. However, Dhrystone numbers obtained under
+these conditions should be explicitly marked as such; "normal"
+Dhrystone results should be understood as results obtained following
+the ground rules listed above.
+
+In any case, for serious performance evaluation, users are advised to
+ask for code listings and to check them carefully. In this way, when
+results for different systems are compared, the reader can get a
+feeling how much performance difference is due to compiler optimization
+and how much is due to hardware speed.
+
+
+The C version 2.1 of Dhrystone has been developed in cooperation with
+Rick Richardson (Tinton Falls, NJ), it incorporates many ideas from the
+"Version 1.1" distributed previously by him over the UNIX network
+Usenet. Through his activity with Usenet, Rick Richardson has made a
+very valuable contribution to the dissemination of the benchmark. I
+also thank Chaim Benedelac (National Semiconductor), David Ditzel
+(SUN), Earl Killian and John Mashey (MIPS), Alan Smith and Rafael
+Saavedra-Barrera (UC at Berkeley) for their help with comments on
+earlier versions of the benchmark.
+
+
+[1]
+ Reinhold P. Weicker: Dhrystone: A Synthetic Systems Programming
+ Benchmark.
+ Communications of the ACM 27, 10 (Oct. 1984), 1013-1030
+
+[2]
+ Rick Richardson: Dhrystone 1.1 Benchmark Summary (and Program Text)
+ Informal Distribution via "Usenet", Last Version Known to me: Sept.
+ 21, 1987
+
+[3]
+ Brian W. Kernighan and Dennis M. Ritchie: The C Programming
+ Language.
+ Prentice-Hall, Englewood Cliffs (NJ) 1978
+
+
+
+
+
diff --git a/hostsidetests/sustainedperf/dhrystone/dhry.h b/hostsidetests/sustainedperf/dhrystone/dhry.h
new file mode 100644
index 0000000..ef96b41
--- /dev/null
+++ b/hostsidetests/sustainedperf/dhrystone/dhry.h
@@ -0,0 +1,436 @@
+/*
+ ****************************************************************************
+ *
+ * "DHRYSTONE" Benchmark Program
+ * -----------------------------
+ *
+ * Version: C, Version 2.1
+ *
+ * File: dhry.h (part 1 of 3)
+ *
+ * Date: May 17, 1988
+ *
+ * Author: Reinhold P. Weicker
+ * Siemens AG, E STE 35
+ * Postfach 3240
+ * 8520 Erlangen
+ * Germany (West)
+ * Phone: [xxx-49]-9131-7-20330
+ * (8-17 Central European Time)
+ * Usenet: ..!mcvax!unido!estevax!weicker
+ *
+ * Original Version (in Ada) published in
+ * "Communications of the ACM" vol. 27., no. 10 (Oct. 1984),
+ * pp. 1013 - 1030, together with the statistics
+ * on which the distribution of statements etc. is based.
+ *
+ * In this C version, the following C library functions are used:
+ * - strcpy, strcmp (inside the measurement loop)
+ * - printf, scanf (outside the measurement loop)
+ * In addition, Berkeley UNIX system calls "times ()" or "time ()"
+ * are used for execution time measurement. For measurements
+ * on other systems, these calls have to be changed.
+ *
+ * Collection of Results:
+ * Reinhold Weicker (address see above) and
+ *
+ * Rick Richardson
+ * PC Research. Inc.
+ * 94 Apple Orchard Drive
+ * Tinton Falls, NJ 07724
+ * Phone: (201) 389-8963 (9-17 EST)
+ * Usenet: ...!uunet!pcrat!rick
+ *
+ * Please send results to Rick Richardson and/or Reinhold Weicker.
+ * Complete information should be given on hardware and software used.
+ * Hardware information includes: Machine type, CPU, type and size
+ * of caches; for microprocessors: clock frequency, memory speed
+ * (number of wait states).
+ * Software information includes: Compiler (and runtime library)
+ * manufacturer and version, compilation switches, OS version.
+ * The Operating System version may give an indication about the
+ * compiler; Dhrystone itself performs no OS calls in the measurement loop.
+ *
+ * The complete output generated by the program should be mailed
+ * such that at least some checks for correctness can be made.
+ *
+ ***************************************************************************
+ *
+ * History: This version C/2.1 has been made for two reasons:
+ *
+ * 1) There is an obvious need for a common C version of
+ * Dhrystone, since C is at present the most popular system
+ * programming language for the class of processors
+ * (microcomputers, minicomputers) where Dhrystone is used most.
+ * There should be, as far as possible, only one C version of
+ * Dhrystone such that results can be compared without
+ * restrictions. In the past, the C versions distributed
+ * by Rick Richardson (Version 1.1) and by Reinhold Weicker
+ * had small (though not significant) differences.
+ *
+ * 2) As far as it is possible without changes to the Dhrystone
+ * statistics, optimizing compilers should be prevented from
+ * removing significant statements.
+ *
+ * This C version has been developed in cooperation with
+ * Rick Richardson (Tinton Falls, NJ), it incorporates many
+ * ideas from the "Version 1.1" distributed previously by
+ * him over the UNIX network Usenet.
+ * I also thank Chaim Benedelac (National Semiconductor),
+ * David Ditzel (SUN), Earl Killian and John Mashey (MIPS),
+ * Alan Smith and Rafael Saavedra-Barrera (UC at Berkeley)
+ * for their help with comments on earlier versions of the
+ * benchmark.
+ *
+ * Changes: In the initialization part, this version follows mostly
+ * Rick Richardson's version distributed via Usenet, not the
+ * version distributed earlier via floppy disk by Reinhold Weicker.
+ * As a concession to older compilers, names have been made
+ * unique within the first 8 characters.
+ * Inside the measurement loop, this version follows the
+ * version previously distributed by Reinhold Weicker.
+ *
+ * At several places in the benchmark, code has been added,
+ * but within the measurement loop only in branches that
+ * are not executed. The intention is that optimizing compilers
+ * should be prevented from moving code out of the measurement
+ * loop, or from removing code altogether. Since the statements
+ * that are executed within the measurement loop have NOT been
+ * changed, the numbers defining the "Dhrystone distribution"
+ * (distribution of statements, operand types and locality)
+ * still hold. Except for sophisticated optimizing compilers,
+ * execution times for this version should be the same as
+ * for previous versions.
+ *
+ * Since it has proven difficult to subtract the time for the
+ * measurement loop overhead in a correct way, the loop check
+ * has been made a part of the benchmark. This does have
+ * an impact - though a very minor one - on the distribution
+ * statistics which have been updated for this version.
+ *
+ * All changes within the measurement loop are described
+ * and discussed in the companion paper "Rationale for
+ * Dhrystone version 2".
+ *
+ * Because of the self-imposed limitation that the order and
+ * distribution of the executed statements should not be
+ * changed, there are still cases where optimizing compilers
+ * may not generate code for some statements. To a certain
+ * degree, this is unavoidable for small synthetic benchmarks.
+ * Users of the benchmark are advised to check code listings
+ * whether code is generated for all statements of Dhrystone.
+ *
+ * Version 2.1 is identical to version 2.0 distributed via
+ * the UNIX network Usenet in March 1988 except that it corrects
+ * some minor deficiencies that were found by users of version 2.0.
+ * The following corrections have been made in the C version:
+ * - The assignment to Number_Of_Runs was changed
+ * - The constant Too_Small_Time was changed
+ * - An "else" part was added to the "if" statement in Func_3;
+ * for compensation, an "else" part was removed in Proc_3
+ * - Shorter file names are used
+ *
+ ***************************************************************************
+ *
+ * Defines: The following "Defines" are possible:
+ * -DREG=register (default: Not defined)
+ * As an approximation to what an average C programmer
+ * might do, the "register" storage class is applied
+ * (if enabled by -DREG=register)
+ * - for local variables, if they are used (dynamically)
+ * five or more times
+ * - for parameters if they are used (dynamically)
+ * six or more times
+ * Note that an optimal "register" strategy is
+ * compiler-dependent, and that "register" declarations
+ * do not necessarily lead to faster execution.
+ * -DNOSTRUCTASSIGN (default: Not defined)
+ * Define if the C compiler does not support
+ * assignment of structures.
+ * -DNOENUMS (default: Not defined)
+ * Define if the C compiler does not support
+ * enumeration types.
+ * -DTIMES (default)
+ * -DTIME
+ * The "times" function of UNIX (returning process times)
+ * or the "time" function (returning wallclock time)
+ * is used for measurement.
+ * For single user machines, "time ()" is adequate. For
+ * multi-user machines where you cannot get single-user
+ * access, use the "times ()" function. If you have
+ * neither, use a stopwatch in the dead of night.
+ * "printf"s are provided marking the points "Start Timer"
+ * and "Stop Timer". DO NOT use the UNIX "time(1)"
+ * command, as this will measure the total time to
+ * run this program, which will (erroneously) include
+ * the time to allocate storage (malloc) and to perform
+ * the initialization.
+ * -DHZ=nnn
+ * In Berkeley UNIX, the function "times" returns process
+ * time in 1/HZ seconds, with HZ = 60 for most systems.
+ * CHECK YOUR SYSTEM DESCRIPTION BEFORE YOU JUST APPLY
+ * A VALUE.
+ *
+ ***************************************************************************
+ *
+ * Compilation model and measurement (IMPORTANT):
+ *
+ * This C version of Dhrystone consists of three files:
+ * - dhry.h (this file, containing global definitions and comments)
+ * - dhry_1.c (containing the code corresponding to Ada package Pack_1)
+ * - dhry_2.c (containing the code corresponding to Ada package Pack_2)
+ *
+ * The following "ground rules" apply for measurements:
+ * - Separate compilation
+ * - No procedure merging
+ * - Otherwise, compiler optimizations are allowed but should be indicated
+ * - Default results are those without register declarations
+ * See the companion paper "Rationale for Dhrystone Version 2" for a more
+ * detailed discussion of these ground rules.
+ *
+ * For 16-Bit processors (e.g. 80186, 80286), times for all compilation
+ * models ("small", "medium", "large" etc.) should be given if possible,
+ * together with a definition of these models for the compiler system used.
+ *
+ **************************************************************************
+ *
+ * Dhrystone (C version) statistics:
+ *
+ * [Comment from the first distribution, updated for version 2.
+ * Note that because of language differences, the numbers are slightly
+ * different from the Ada version.]
+ *
+ * The following program contains statements of a high level programming
+ * language (here: C) in a distribution considered representative:
+ *
+ * assignments 52 (51.0 %)
+ * control statements 33 (32.4 %)
+ * procedure, function calls 17 (16.7 %)
+ *
+ * 103 statements are dynamically executed. The program is balanced with
+ * respect to the three aspects:
+ *
+ * - statement type
+ * - operand type
+ * - operand locality
+ * operand global, local, parameter, or constant.
+ *
+ * The combination of these three aspects is balanced only approximately.
+ *
+ * 1. Statement Type:
+ * ----------------- number
+ *
+ * V1 = V2 9
+ * (incl. V1 = F(..)
+ * V = Constant 12
+ * Assignment, 7
+ * with array element
+ * Assignment, 6
+ * with record component
+ * --
+ * 34 34
+ *
+ * X = Y +|-|"&&"|"|" Z 5
+ * X = Y +|-|"==" Constant 6
+ * X = X +|- 1 3
+ * X = Y *|/ Z 2
+ * X = Expression, 1
+ * two operators
+ * X = Expression, 1
+ * three operators
+ * --
+ * 18 18
+ *
+ * if .... 14
+ * with "else" 7
+ * without "else" 7
+ * executed 3
+ * not executed 4
+ * for ... 7 | counted every time
+ * while ... 4 | the loop condition
+ * do ... while 1 | is evaluated
+ * switch ... 1
+ * break 1
+ * declaration with 1
+ * initialization
+ * --
+ * 34 34
+ *
+ * P (...) procedure call 11
+ * user procedure 10
+ * library procedure 1
+ * X = F (...)
+ * function call 6
+ * user function 5
+ * library function 1
+ * --
+ * 17 17
+ * ---
+ * 103
+ *
+ * The average number of parameters in procedure or function calls
+ * is 1.82 (not counting the function values as implicit parameters).
+ *
+ *
+ * 2. Operators
+ * ------------
+ * number approximate
+ * percentage
+ *
+ * Arithmetic 32 50.8
+ *
+ * + 21 33.3
+ * - 7 11.1
+ * * 3 4.8
+ * / (int div) 1 1.6
+ *
+ * Comparison 27 42.8
+ *
+ * == 9 14.3
+ * /= 4 6.3
+ * > 1 1.6
+ * < 3 4.8
+ * >= 1 1.6
+ * <= 9 14.3
+ *
+ * Logic 4 6.3
+ *
+ * && (AND-THEN) 1 1.6
+ * | (OR) 1 1.6
+ * ! (NOT) 2 3.2
+ *
+ * -- -----
+ * 63 100.1
+ *
+ *
+ * 3. Operand Type (counted once per operand reference):
+ * ---------------
+ * number approximate
+ * percentage
+ *
+ * Integer 175 72.3 %
+ * Character 45 18.6 %
+ * Pointer 12 5.0 %
+ * String30 6 2.5 %
+ * Array 2 0.8 %
+ * Record 2 0.8 %
+ * --- -------
+ * 242 100.0 %
+ *
+ * When there is an access path leading to the final operand (e.g. a record
+ * component), only the final data type on the access path is counted.
+ *
+ *
+ * 4. Operand Locality:
+ * -------------------
+ * number approximate
+ * percentage
+ *
+ * local variable 114 47.1 %
+ * global variable 22 9.1 %
+ * parameter 45 18.6 %
+ * value 23 9.5 %
+ * reference 22 9.1 %
+ * function result 6 2.5 %
+ * constant 55 22.7 %
+ * --- -------
+ * 242 100.0 %
+ *
+ *
+ * The program does not compute anything meaningful, but it is syntactically
+ * and semantically correct. All variables have a value assigned to them
+ * before they are used as a source operand.
+ *
+ * There has been no explicit effort to account for the effects of a
+ * cache, or to balance the use of long or short displacements for code or
+ * data.
+ *
+ ***************************************************************************
+ */
+
+/* Compiler and system dependent definitions: */
+
+#ifndef TIME
+#ifndef TIMES
+#define TIMES
+#endif
+#endif
+ /* Use times(2) time function unless */
+ /* explicitly defined otherwise */
+
+#ifdef MSC_CLOCK
+#undef HZ
+#undef TIMES
+#include <time.h>
+#define HZ CLK_TCK
+#endif
+ /* Use Microsoft C hi-res clock */
+
+#ifdef TIMES
+#include <sys/types.h>
+#include <sys/times.h>
+ /* for "times" */
+#endif
+
+#define Mic_secs_Per_Second 1000000.0
+ /* Berkeley UNIX C returns process times in seconds/HZ */
+
+#ifdef NOSTRUCTASSIGN
+#define structassign(d, s) memcpy(&(d), &(s), sizeof(d))
+#else
+#define structassign(d, s) d = s
+#endif
+
+#ifdef NOENUM
+#define Ident_1 0
+#define Ident_2 1
+#define Ident_3 2
+#define Ident_4 3
+#define Ident_5 4
+ typedef int Enumeration;
+#else
+ typedef enum {Ident_1, Ident_2, Ident_3, Ident_4, Ident_5}
+ Enumeration;
+#endif
+ /* for boolean and enumeration types in Ada, Pascal */
+
+/* General definitions: */
+
+#include <stdio.h>
+ /* for strcpy, strcmp */
+
+#define Null 0
+ /* Value of a Null pointer */
+#define true 1
+#define false 0
+
+typedef int One_Thirty;
+typedef int One_Fifty;
+typedef char Capital_Letter;
+typedef int Boolean;
+typedef char Str_30 [31];
+typedef int Arr_1_Dim [50];
+typedef int Arr_2_Dim [50] [50];
+
+typedef struct record
+ {
+ struct record *Ptr_Comp;
+ Enumeration Discr;
+ union {
+ struct {
+ Enumeration Enum_Comp;
+ int Int_Comp;
+ char Str_Comp [31];
+ } var_1;
+ struct {
+ Enumeration E_Comp_2;
+ char Str_2_Comp [31];
+ } var_2;
+ struct {
+ char Ch_1_Comp;
+ char Ch_2_Comp;
+ } var_3;
+ } variant;
+ } Rec_Type, *Rec_Pointer;
+
+
diff --git a/hostsidetests/sustainedperf/dhrystone/dhry_1.c b/hostsidetests/sustainedperf/dhrystone/dhry_1.c
new file mode 100644
index 0000000..c1198d1
--- /dev/null
+++ b/hostsidetests/sustainedperf/dhrystone/dhry_1.c
@@ -0,0 +1,318 @@
+/*
+ ****************************************************************************
+ *
+ * "DHRYSTONE" Benchmark Program
+ * -----------------------------
+ *
+ * Version: C, Version 2.1
+ *
+ * File: dhry_1.c (part 2 of 3)
+ *
+ * Date: May 17, 1988
+ *
+ * Author: Reinhold P. Weicker
+ *
+ ****************************************************************************
+ */
+
+#include "dhry.h"
+
+/* Global Variables: */
+
+Rec_Pointer Ptr_Glob,
+ Next_Ptr_Glob;
+int Int_Glob;
+Boolean Bool_Glob;
+char Ch_1_Glob,
+ Ch_2_Glob;
+int Arr_1_Glob [50];
+int Arr_2_Glob [50] [50];
+
+extern char *malloc ();
+Enumeration Func_1 ();
+ /* forward declaration necessary since Enumeration may not simply be int */
+
+#ifndef REG
+ Boolean Reg = false;
+#define REG
+ /* REG becomes defined as empty */
+ /* i.e. no register variables */
+#else
+ Boolean Reg = true;
+#endif
+
+/* variables for time measurement: */
+
+#ifdef TIMES
+struct tms time_info;
+extern int times ();
+ /* see library function "times" */
+#define Too_Small_Time (2*HZ)
+ /* Measurements should last at least about 2 seconds */
+#endif
+#ifdef TIME
+extern long time();
+ /* see library function "time" */
+#define Too_Small_Time 2
+ /* Measurements should last at least 2 seconds */
+#endif
+#ifdef MSC_CLOCK
+extern clock_t clock();
+#define Too_Small_Time (2*HZ)
+#endif
+
+long Begin_Time,
+ End_Time,
+ User_Time;
+float Microseconds,
+ Dhrystones_Per_Second;
+
+/* end of variables for time measurement */
+
+
+main ()
+/*****/
+
+ /* main program, corresponds to procedures */
+ /* Main and Proc_0 in the Ada version */
+{
+ One_Fifty Int_1_Loc;
+ REG One_Fifty Int_2_Loc;
+ One_Fifty Int_3_Loc;
+ REG char Ch_Index;
+ Enumeration Enum_Loc;
+ Str_30 Str_1_Loc;
+ Str_30 Str_2_Loc;
+ REG int Run_Index;
+ REG int Number_Of_Runs;
+
+ /* Initializations */
+
+ Next_Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
+ Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
+
+ Ptr_Glob->Ptr_Comp = Next_Ptr_Glob;
+ Ptr_Glob->Discr = Ident_1;
+ Ptr_Glob->variant.var_1.Enum_Comp = Ident_3;
+ Ptr_Glob->variant.var_1.Int_Comp = 40;
+ strcpy (Ptr_Glob->variant.var_1.Str_Comp,
+ "DHRYSTONE PROGRAM, SOME STRING");
+ strcpy (Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING");
+
+ Arr_2_Glob [8][7] = 10;
+ /* Was missing in published program. Without this statement, */
+ /* Arr_2_Glob [8][7] would have an undefined value. */
+ /* Warning: With 16-Bit processors and Number_Of_Runs > 32000, */
+ /* overflow may occur for this array element. */
+ int n;
+ scanf ("%d", &n);
+ Number_Of_Runs = n;
+
+
+ /***************/
+ /* Start timer */
+ /***************/
+
+#ifdef TIMES
+ times (&time_info);
+ Begin_Time = (long) time_info.tms_utime;
+#endif
+#ifdef TIME
+ Begin_Time = time ( (long *) 0);
+#endif
+#ifdef MSC_CLOCK
+ Begin_Time = clock();
+#endif
+
+ for (Run_Index = 1; Run_Index <= Number_Of_Runs; ++Run_Index)
+ {
+
+ Proc_5();
+ Proc_4();
+ /* Ch_1_Glob == 'A', Ch_2_Glob == 'B', Bool_Glob == true */
+ Int_1_Loc = 2;
+ Int_2_Loc = 3;
+ strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING");
+ Enum_Loc = Ident_2;
+ Bool_Glob = ! Func_2 (Str_1_Loc, Str_2_Loc);
+ /* Bool_Glob == 1 */
+ while (Int_1_Loc < Int_2_Loc) /* loop body executed once */
+ {
+ Int_3_Loc = 5 * Int_1_Loc - Int_2_Loc;
+ /* Int_3_Loc == 7 */
+ Proc_7 (Int_1_Loc, Int_2_Loc, &Int_3_Loc);
+ /* Int_3_Loc == 7 */
+ Int_1_Loc += 1;
+ } /* while */
+ /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
+ Proc_8 (Arr_1_Glob, Arr_2_Glob, Int_1_Loc, Int_3_Loc);
+ /* Int_Glob == 5 */
+ Proc_1 (Ptr_Glob);
+ for (Ch_Index = 'A'; Ch_Index <= Ch_2_Glob; ++Ch_Index)
+ /* loop body executed twice */
+ {
+ if (Enum_Loc == Func_1 (Ch_Index, 'C'))
+ /* then, not executed */
+ {
+ Proc_6 (Ident_1, &Enum_Loc);
+ strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 3'RD STRING");
+ Int_2_Loc = Run_Index;
+ Int_Glob = Run_Index;
+ }
+ }
+ /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
+ Int_2_Loc = Int_2_Loc * Int_1_Loc;
+ Int_1_Loc = Int_2_Loc / Int_3_Loc;
+ Int_2_Loc = 7 * (Int_2_Loc - Int_3_Loc) - Int_1_Loc;
+ /* Int_1_Loc == 1, Int_2_Loc == 13, Int_3_Loc == 7 */
+ Proc_2 (&Int_1_Loc);
+ /* Int_1_Loc == 5 */
+
+ } /* loop "for Run_Index" */
+
+ /**************/
+ /* Stop timer */
+ /**************/
+
+#ifdef TIMES
+ times (&time_info);
+ End_Time = (long) time_info.tms_utime;
+#endif
+#ifdef TIME
+ End_Time = time ( (long *) 0);
+#endif
+#ifdef MSC_CLOCK
+ End_Time = clock();
+#endif
+ User_Time = End_Time - Begin_Time;
+
+ if (User_Time < Too_Small_Time)
+ {
+ printf ("Measured time too small to obtain meaningful results\n");
+ printf ("Please increase number of runs\n");
+ printf ("\n");
+ }
+ else
+ {
+#ifdef TIME
+ Microseconds = (float) User_Time * Mic_secs_Per_Second
+ / (float) Number_Of_Runs;
+ Dhrystones_Per_Second = (float) Number_Of_Runs / (float) User_Time;
+#else
+ Microseconds = (float) User_Time * Mic_secs_Per_Second
+ / ((float) HZ * ((float) Number_Of_Runs));
+ Dhrystones_Per_Second = ((float) HZ * (float) Number_Of_Runs)
+ / (float) User_Time;
+#endif
+ printf ("%6.1f \n", Dhrystones_Per_Second);
+ }
+
+}
+
+
+Proc_1 (Ptr_Val_Par)
+/******************/
+
+REG Rec_Pointer Ptr_Val_Par;
+ /* executed once */
+{
+ REG Rec_Pointer Next_Record = Ptr_Val_Par->Ptr_Comp;
+ /* == Ptr_Glob_Next */
+ /* Local variable, initialized with Ptr_Val_Par->Ptr_Comp, */
+ /* corresponds to "rename" in Ada, "with" in Pascal */
+
+ structassign (*Ptr_Val_Par->Ptr_Comp, *Ptr_Glob);
+ Ptr_Val_Par->variant.var_1.Int_Comp = 5;
+ Next_Record->variant.var_1.Int_Comp
+ = Ptr_Val_Par->variant.var_1.Int_Comp;
+ Next_Record->Ptr_Comp = Ptr_Val_Par->Ptr_Comp;
+ Proc_3 (&Next_Record->Ptr_Comp);
+ /* Ptr_Val_Par->Ptr_Comp->Ptr_Comp
+ == Ptr_Glob->Ptr_Comp */
+ if (Next_Record->Discr == Ident_1)
+ /* then, executed */
+ {
+ Next_Record->variant.var_1.Int_Comp = 6;
+ Proc_6 (Ptr_Val_Par->variant.var_1.Enum_Comp,
+ &Next_Record->variant.var_1.Enum_Comp);
+ Next_Record->Ptr_Comp = Ptr_Glob->Ptr_Comp;
+ Proc_7 (Next_Record->variant.var_1.Int_Comp, 10,
+ &Next_Record->variant.var_1.Int_Comp);
+ }
+ else /* not executed */
+ structassign (*Ptr_Val_Par, *Ptr_Val_Par->Ptr_Comp);
+return 0; } /* Proc_1 */
+
+
+Proc_2 (Int_Par_Ref)
+/******************/
+ /* executed once */
+ /* *Int_Par_Ref == 1, becomes 4 */
+
+One_Fifty *Int_Par_Ref;
+{
+ One_Fifty Int_Loc;
+ Enumeration Enum_Loc;
+
+ Int_Loc = *Int_Par_Ref + 10;
+ do /* executed once */
+ if (Ch_1_Glob == 'A')
+ /* then, executed */
+ {
+ Int_Loc -= 1;
+ *Int_Par_Ref = Int_Loc - Int_Glob;
+ Enum_Loc = Ident_1;
+ } /* if */
+ while (Enum_Loc != Ident_1); /* true */
+return 0; } /* Proc_2 */
+
+
+Proc_3 (Ptr_Ref_Par)
+/******************/
+ /* executed once */
+ /* Ptr_Ref_Par becomes Ptr_Glob */
+
+Rec_Pointer *Ptr_Ref_Par;
+
+{
+ if (Ptr_Glob != Null)
+ /* then, executed */
+ *Ptr_Ref_Par = Ptr_Glob->Ptr_Comp;
+ Proc_7 (10, Int_Glob, &Ptr_Glob->variant.var_1.Int_Comp);
+return 0; } /* Proc_3 */
+
+
+Proc_4 () /* without parameters */
+/*******/
+ /* executed once */
+{
+ Boolean Bool_Loc;
+
+ Bool_Loc = Ch_1_Glob == 'A';
+ Bool_Glob = Bool_Loc | Bool_Glob;
+ Ch_2_Glob = 'B';
+return 0; } /* Proc_4 */
+
+
+Proc_5 () /* without parameters */
+/*******/
+ /* executed once */
+{
+ Ch_1_Glob = 'A';
+ Bool_Glob = false;
+return 0; } /* Proc_5 */
+
+
+ /* Procedure for the assignment of structures, */
+ /* if the C compiler doesn't support this feature */
+#ifdef NOSTRUCTASSIGN
+memcpy (d, s, l)
+register char *d;
+register char *s;
+register int l;
+{
+ while (l--) *d++ = *s++;
+}
+#endif
+
+
diff --git a/hostsidetests/sustainedperf/dhrystone/dhry_2.c b/hostsidetests/sustainedperf/dhrystone/dhry_2.c
new file mode 100644
index 0000000..3166a7e
--- /dev/null
+++ b/hostsidetests/sustainedperf/dhrystone/dhry_2.c
@@ -0,0 +1,192 @@
+/*
+ ****************************************************************************
+ *
+ * "DHRYSTONE" Benchmark Program
+ * -----------------------------
+ *
+ * Version: C, Version 2.1
+ *
+ * File: dhry_2.c (part 3 of 3)
+ *
+ * Date: May 17, 1988
+ *
+ * Author: Reinhold P. Weicker
+ *
+ ****************************************************************************
+ */
+
+#include "dhry.h"
+
+#ifndef REG
+#define REG
+ /* REG becomes defined as empty */
+ /* i.e. no register variables */
+#endif
+
+extern int Int_Glob;
+extern char Ch_1_Glob;
+
+
+Proc_6 (Enum_Val_Par, Enum_Ref_Par)
+/*********************************/
+ /* executed once */
+ /* Enum_Val_Par == Ident_3, Enum_Ref_Par becomes Ident_2 */
+
+Enumeration Enum_Val_Par;
+Enumeration *Enum_Ref_Par;
+{
+ *Enum_Ref_Par = Enum_Val_Par;
+ if (! Func_3 (Enum_Val_Par))
+ /* then, not executed */
+ *Enum_Ref_Par = Ident_4;
+ switch (Enum_Val_Par)
+ {
+ case Ident_1:
+ *Enum_Ref_Par = Ident_1;
+ break;
+ case Ident_2:
+ if (Int_Glob > 100)
+ /* then */
+ *Enum_Ref_Par = Ident_1;
+ else *Enum_Ref_Par = Ident_4;
+ break;
+ case Ident_3: /* executed */
+ *Enum_Ref_Par = Ident_2;
+ break;
+ case Ident_4: break;
+ case Ident_5:
+ *Enum_Ref_Par = Ident_3;
+ break;
+ } /* switch */
+return 0; } /* Proc_6 */
+
+
+Proc_7 (Int_1_Par_Val, Int_2_Par_Val, Int_Par_Ref)
+/**********************************************/
+ /* executed three times */
+ /* first call: Int_1_Par_Val == 2, Int_2_Par_Val == 3, */
+ /* Int_Par_Ref becomes 7 */
+ /* second call: Int_1_Par_Val == 10, Int_2_Par_Val == 5, */
+ /* Int_Par_Ref becomes 17 */
+ /* third call: Int_1_Par_Val == 6, Int_2_Par_Val == 10, */
+ /* Int_Par_Ref becomes 18 */
+One_Fifty Int_1_Par_Val;
+One_Fifty Int_2_Par_Val;
+One_Fifty *Int_Par_Ref;
+{
+ One_Fifty Int_Loc;
+
+ Int_Loc = Int_1_Par_Val + 2;
+ *Int_Par_Ref = Int_2_Par_Val + Int_Loc;
+return 0; } /* Proc_7 */
+
+
+Proc_8 (Arr_1_Par_Ref, Arr_2_Par_Ref, Int_1_Par_Val, Int_2_Par_Val)
+/*********************************************************************/
+ /* executed once */
+ /* Int_Par_Val_1 == 3 */
+ /* Int_Par_Val_2 == 7 */
+Arr_1_Dim Arr_1_Par_Ref;
+Arr_2_Dim Arr_2_Par_Ref;
+int Int_1_Par_Val;
+int Int_2_Par_Val;
+{
+ REG One_Fifty Int_Index;
+ REG One_Fifty Int_Loc;
+
+ Int_Loc = Int_1_Par_Val + 5;
+ Arr_1_Par_Ref [Int_Loc] = Int_2_Par_Val;
+ Arr_1_Par_Ref [Int_Loc+1] = Arr_1_Par_Ref [Int_Loc];
+ Arr_1_Par_Ref [Int_Loc+30] = Int_Loc;
+ for (Int_Index = Int_Loc; Int_Index <= Int_Loc+1; ++Int_Index)
+ Arr_2_Par_Ref [Int_Loc] [Int_Index] = Int_Loc;
+ Arr_2_Par_Ref [Int_Loc] [Int_Loc-1] += 1;
+ Arr_2_Par_Ref [Int_Loc+20] [Int_Loc] = Arr_1_Par_Ref [Int_Loc];
+ Int_Glob = 5;
+return 0; } /* Proc_8 */
+
+
+Enumeration Func_1 (Ch_1_Par_Val, Ch_2_Par_Val)
+/*************************************************/
+ /* executed three times */
+ /* first call: Ch_1_Par_Val == 'H', Ch_2_Par_Val == 'R' */
+ /* second call: Ch_1_Par_Val == 'A', Ch_2_Par_Val == 'C' */
+ /* third call: Ch_1_Par_Val == 'B', Ch_2_Par_Val == 'C' */
+
+Capital_Letter Ch_1_Par_Val;
+Capital_Letter Ch_2_Par_Val;
+{
+ Capital_Letter Ch_1_Loc;
+ Capital_Letter Ch_2_Loc;
+
+ Ch_1_Loc = Ch_1_Par_Val;
+ Ch_2_Loc = Ch_1_Loc;
+ if (Ch_2_Loc != Ch_2_Par_Val)
+ /* then, executed */
+ return (Ident_1);
+ else /* not executed */
+ {
+ Ch_1_Glob = Ch_1_Loc;
+ return (Ident_2);
+ }
+} /* Func_1 */
+
+
+Boolean Func_2 (Str_1_Par_Ref, Str_2_Par_Ref)
+/*************************************************/
+ /* executed once */
+ /* Str_1_Par_Ref == "DHRYSTONE PROGRAM, 1'ST STRING" */
+ /* Str_2_Par_Ref == "DHRYSTONE PROGRAM, 2'ND STRING" */
+
+Str_30 Str_1_Par_Ref;
+Str_30 Str_2_Par_Ref;
+{
+ REG One_Thirty Int_Loc;
+ Capital_Letter Ch_Loc;
+
+ Int_Loc = 2;
+ while (Int_Loc <= 2) /* loop body executed once */
+ if (Func_1 (Str_1_Par_Ref[Int_Loc],
+ Str_2_Par_Ref[Int_Loc+1]) == Ident_1)
+ /* then, executed */
+ {
+ Ch_Loc = 'A';
+ Int_Loc += 1;
+ } /* if, while */
+ if (Ch_Loc >= 'W' && Ch_Loc < 'Z')
+ /* then, not executed */
+ Int_Loc = 7;
+ if (Ch_Loc == 'R')
+ /* then, not executed */
+ return (true);
+ else /* executed */
+ {
+ if (strcmp (Str_1_Par_Ref, Str_2_Par_Ref) > 0)
+ /* then, not executed */
+ {
+ Int_Loc += 7;
+ Int_Glob = Int_Loc;
+ return (true);
+ }
+ else /* executed */
+ return (false);
+ } /* if Ch_Loc */
+} /* Func_2 */
+
+
+Boolean Func_3 (Enum_Par_Val)
+/***************************/
+ /* executed once */
+ /* Enum_Par_Val == Ident_3 */
+Enumeration Enum_Par_Val;
+{
+ Enumeration Enum_Loc;
+
+ Enum_Loc = Enum_Par_Val;
+ if (Enum_Loc == Ident_3)
+ /* then, executed */
+ return (true);
+ else /* not executed */
+ return (false);
+} /* Func_3 */
+
diff --git a/hostsidetests/sustainedperf/shadertoy_android/Android.mk b/hostsidetests/sustainedperf/shadertoy_android/Android.mk
new file mode 100644
index 0000000..0c6c2a4
--- /dev/null
+++ b/hostsidetests/sustainedperf/shadertoy_android/Android.mk
@@ -0,0 +1,38 @@
+# Copyright (C) 2008 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+# don't include this package in any target
+LOCAL_MODULE_TAGS := tests
+# and when built explicitly put it in the data partition
+LOCAL_MODULE_PATH := $(TARGET_OUT_DATA_APPS)
+
+# Include both the 32 and 64 bit versions
+LOCAL_MULTILIB := both
+
+LOCAL_JNI_SHARED_LIBRARIES := libgltest libc++
+#LOCAL_SHARED_LIBRARIES := libc++
+#LOCAL_STATIC_LIBRARIES := libc++_static
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+LOCAL_PACKAGE_NAME := CtsSustainedPerformanceTestCases
+
+LOCAL_SDK_VERSION := current
+
+# Tag this module as a cts test artifact
+LOCAL_COMPATIBILITY_SUITE := cts
+include $(BUILD_PACKAGE)
+include $(call all-makefiles-under,$(LOCAL_PATH))
diff --git a/hostsidetests/sustainedperf/shadertoy_android/AndroidManifest.xml b/hostsidetests/sustainedperf/shadertoy_android/AndroidManifest.xml
new file mode 100644
index 0000000..77dee18
--- /dev/null
+++ b/hostsidetests/sustainedperf/shadertoy_android/AndroidManifest.xml
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+**
+** Copyright 2009, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+-->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="com.android.gputest">
+ <application
+ android:label="@string/gpustresstest_activity">
+ <activity android:name="GPUStressTestActivity"
+ android:theme="@android:style/Theme.NoTitleBar.Fullscreen"
+ android:launchMode="singleTask"
+ android:configChanges="orientation|keyboardHidden">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN" />
+ <category android:name="android.intent.category.LAUNCHER" />
+ </intent-filter>
+ </activity>
+ </application>
+ <uses-feature android:glEsVersion="0x00020000"/>
+ <uses-sdk android:minSdkVersion="5"/>
+ <uses-permission android:name="android.permission.INTERNET" />
+ <uses-permission android:name="com.qti.permission.PROFILER" />
+ <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
+ <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
+</manifest>
diff --git a/hostsidetests/sustainedperf/shadertoy_android/jni/Android.mk b/hostsidetests/sustainedperf/shadertoy_android/jni/Android.mk
new file mode 100644
index 0000000..2859b30
--- /dev/null
+++ b/hostsidetests/sustainedperf/shadertoy_android/jni/Android.mk
@@ -0,0 +1,32 @@
+# Copyright (C) 2016 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libgltest
+
+LOCAL_SRC_FILES := shaders.cpp \
+ shadertoy_renderer.cpp \
+ shadertoy_shader.cpp \
+ hooks_android.cpp \
+ utils.cpp
+
+LOCAL_SDK_VERSION := 21
+LOCAL_NDK_STL_VARIANT := c++_static
+
+LOCAL_LDLIBS := -llog -lGLESv3 -lEGL -ldl
+include $(BUILD_SHARED_LIBRARY)
diff --git a/hostsidetests/sustainedperf/shadertoy_android/jni/Application.mk b/hostsidetests/sustainedperf/shadertoy_android/jni/Application.mk
new file mode 100644
index 0000000..433f6cf
--- /dev/null
+++ b/hostsidetests/sustainedperf/shadertoy_android/jni/Application.mk
@@ -0,0 +1,23 @@
+# Copyright (C) 2016 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+NDK_TOOLCHAIN_VERSION := 4.8
+APP_ABI := armeabi-v7a
+APP_PLATFORM := android-22
+
+# Enable C++11. However, pthread, rtti and exceptions aren’t enabled
+APP_CPPFLAGS += -std=c++11
+APP_STL := gnustl_static
+LOCAL_C_INCLUDES += ${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/4.8/include
diff --git a/hostsidetests/sustainedperf/shadertoy_android/jni/hooks_android.cpp b/hostsidetests/sustainedperf/shadertoy_android/jni/hooks_android.cpp
new file mode 100644
index 0000000..d6b83f4
--- /dev/null
+++ b/hostsidetests/sustainedperf/shadertoy_android/jni/hooks_android.cpp
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <jni.h>
+
+extern void Init(int width, int height);
+extern void DrawFrame();
+extern void Cleanup();
+
+extern "C" {
+ JNIEXPORT void JNICALL Java_com_android_gputest_GLtestLib_init(JNIEnv * env, jobject obj, jint width, jint height);
+ JNIEXPORT void JNICALL Java_com_android_gputest_GLtestLib_step(JNIEnv * env, jobject obj);
+};
+
+JNIEXPORT void JNICALL Java_com_android_gputest_GLtestLib_init(__attribute__((unused)) JNIEnv * env,__attribute__((unused)) jobject obj, jint width, jint height)
+{
+ Init(width, height);
+}
+
+JNIEXPORT void JNICALL Java_com_android_gputest_GLtestLib_step(__attribute__((unused)) JNIEnv * env,__attribute__((unused)) jobject obj)
+{
+ DrawFrame();
+}
diff --git a/hostsidetests/sustainedperf/shadertoy_android/jni/shaders.cpp b/hostsidetests/sustainedperf/shadertoy_android/jni/shaders.cpp
new file mode 100644
index 0000000..105652d
--- /dev/null
+++ b/hostsidetests/sustainedperf/shadertoy_android/jni/shaders.cpp
@@ -0,0 +1,152 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <string>
+
+std::string g_shader = R"(
+
+// various noise functions
+float Hash2d(vec2 uv)
+{
+ float f = uv.x + uv.y * 47.0;
+ return fract(cos(f*3.333)*100003.9);
+}
+float Hash3d(vec3 uv)
+{
+ float f = uv.x + uv.y * 37.0 + uv.z * 521.0;
+ return fract(cos(f*3.333)*100003.9);
+}
+float mixP(float f0, float f1, float a)
+{
+ return mix(f0, f1, a*a*(3.0-2.0*a));
+}
+const vec2 zeroOne = vec2(0.0, 1.0);
+float noise2d(vec2 uv)
+{
+ vec2 fr = fract(uv.xy);
+ vec2 fl = floor(uv.xy);
+ float h00 = Hash2d(fl);
+ float h10 = Hash2d(fl + zeroOne.yx);
+ float h01 = Hash2d(fl + zeroOne);
+ float h11 = Hash2d(fl + zeroOne.yy);
+ return mixP(mixP(h00, h10, fr.x), mixP(h01, h11, fr.x), fr.y);
+}
+float noise2dT(vec2 uv)
+{
+ vec2 fr = fract(uv);
+ vec2 smooth = fr*fr*(3.0-2.0*fr);
+ vec2 fl = floor(uv);
+ uv = smooth + fl;
+ return texture2D(iChannel0, (uv + 0.5)/iChannelResolution[0].xy).y; // use constant here instead?
+}
+float noise(vec3 uv)
+{
+ vec3 fr = fract(uv.xyz);
+ vec3 fl = floor(uv.xyz);
+ float h000 = Hash3d(fl);
+ float h100 = Hash3d(fl + zeroOne.yxx);
+ float h010 = Hash3d(fl + zeroOne.xyx);
+ float h110 = Hash3d(fl + zeroOne.yyx);
+ float h001 = Hash3d(fl + zeroOne.xxy);
+ float h101 = Hash3d(fl + zeroOne.yxy);
+ float h011 = Hash3d(fl + zeroOne.xyy);
+ float h111 = Hash3d(fl + zeroOne.yyy);
+ return mixP(
+ mixP(mixP(h000, h100, fr.x), mixP(h010, h110, fr.x), fr.y),
+ mixP(mixP(h001, h101, fr.x), mixP(h011, h111, fr.x), fr.y)
+ , fr.z);
+}
+
+float PI=3.14159265;
+
+vec3 saturate(vec3 a)
+{
+ return clamp(a, 0.0, 1.0);
+}
+vec2 saturate(vec2 a)
+{
+ return clamp(a, 0.0, 1.0);
+}
+float saturate(float a)
+{
+ return clamp(a, 0.0, 1.0);
+}
+
+float Density(vec3 p)
+{
+ //float ws = 0.06125*0.125;
+ //vec3 warp = vec3(noise(p*ws), noise(p*ws + 111.11), noise(p*ws + 7111.11));
+ float final = noise(p*0.06125);// + sin(iGlobalTime)*0.5-1.95 + warp.x*4.0;
+ float other = noise(p*0.06125 + 1234.567);
+ other -= 0.5;
+ final -= 0.5;
+ final = 0.1/(abs(final*final*other));
+ final += 0.5;
+ return final*0.0001;
+}
+
+void mainImage( out vec4 fragColor, in vec2 fragCoord )
+{
+ // ---------------- First, set up the camera rays for ray marching ----------------
+ vec2 uv = fragCoord.xy/iResolution.xy * 2.0 - 1.0;// - 0.5;
+
+ // Camera up vector.
+ vec3 camUp=vec3(0,1,0); // vuv
+
+ // Camera lookat.
+ vec3 camLookat=vec3(0,0.0,0); // vrp
+
+ float mx=iMouse.x/iResolution.x*PI*2.0 + iGlobalTime * 0.01;
+ float my=-iMouse.y/iResolution.y*10.0 + sin(iGlobalTime * 0.03)*0.2+0.2;//*PI/2.01;
+ vec3 camPos=vec3(cos(my)*cos(mx),sin(my),cos(my)*sin(mx))*(200.2); // prp
+
+ // Camera setup.
+ vec3 camVec=normalize(camLookat - camPos);//vpn
+ vec3 sideNorm=normalize(cross(camUp, camVec)); // u
+ vec3 upNorm=cross(camVec, sideNorm);//v
+ vec3 worldFacing=(camPos + camVec);//vcv
+ vec3 worldPix = worldFacing + uv.x * sideNorm * (iResolution.x/iResolution.y) + uv.y * upNorm;//scrCoord
+ vec3 relVec = normalize(worldPix - camPos);//scp
+
+ // --------------------------------------------------------------------------------
+ float t = 0.0;
+ float inc = 0.02;
+ float maxDepth = 70.0;
+ vec3 pos = vec3(0,0,0);
+ float density = 0.0;
+ // ray marching time
+ for (int i = 0; i < 37; i++) // This is the count of how many times the ray actually marches.
+ {
+ if ((t > maxDepth)) break;
+ pos = camPos + relVec * t;
+ float temp = Density(pos);
+ //temp *= saturate(t-1.0);
+
+ inc = 1.9 + temp*0.05; // add temp because this makes it look extra crazy!
+ density += temp * inc;
+ t += inc;
+ }
+
+ // --------------------------------------------------------------------------------
+ // Now that we have done our ray marching, let's put some color on this.
+ vec3 finalColor = vec3(0.01,0.1,1.0)* density*0.2;
+
+ // output the final color with sqrt for "gamma correction"
+ fragColor = vec4(sqrt(clamp(finalColor, 0.0, 1.0)),1.0);
+}
+
+
+)";
diff --git a/hostsidetests/sustainedperf/shadertoy_android/jni/shadertoy_renderer.cpp b/hostsidetests/sustainedperf/shadertoy_android/jni/shadertoy_renderer.cpp
new file mode 100644
index 0000000..7718784
--- /dev/null
+++ b/hostsidetests/sustainedperf/shadertoy_android/jni/shadertoy_renderer.cpp
@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "shadertoy_shader.h"
+#include "utils.h"
+
+#include <fstream>
+#include <sstream>
+#include <android/log.h>
+
+int g_framebuffer_width = 0;
+int g_framebuffer_height = 0;
+GLuint g_quad_vao = 0;
+
+ShadertoyShader shader;
+
+#define LOG_TAG "GPUStressTestActivity"
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
+
+double NowInMs() {
+ timespec timeval;
+ clock_gettime(CLOCK_REALTIME, &timeval);
+ double time = 1000.0 * timeval.tv_sec + (double) timeval.tv_nsec / 1e6;
+ return time;
+}
+
+
+GLuint CreateFullscreenQuad() {
+ GLfloat quadVertices[] = {
+ // Positions
+ -1.0f, 1.0f,
+ -1.0f, -1.0f,
+ 1.0f, -1.0f,
+
+ -1.0f, 1.0f,
+ 1.0f, -1.0f,
+ 1.0f, 1.0f,
+ };
+
+ // Setup screen VAO
+ GLuint quadVAO, quadVBO;
+ glGenVertexArrays(1, &quadVAO);
+ glGenBuffers(1, &quadVBO);
+ glBindVertexArray(quadVAO);
+ glBindBuffer(GL_ARRAY_BUFFER, quadVBO);
+ glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), &quadVertices, GL_STATIC_DRAW);
+ glEnableVertexAttribArray(0);
+ glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), (GLvoid*)0);
+ glBindVertexArray(0);
+
+ return quadVAO;
+}
+
+void CreateShader() {
+ extern std::string g_shader;
+ shader.CreateShaderFromString(g_shader);
+}
+
+void Init(int width, int height) {
+ GLint num_extensions = 0;
+ glGetIntegerv(GL_NUM_EXTENSIONS, &num_extensions);
+ for (GLint i = 0; i < num_extensions; ++i) {
+ const char* extension = (char*)(
+ glGetStringi(GL_EXTENSIONS, i));
+ }
+
+ g_framebuffer_width = width;
+ g_framebuffer_height = height;
+
+
+ CreateShader();
+ g_quad_vao = CreateFullscreenQuad();
+}
+
+void DrawFrame() {
+ static double previous_time = 0;
+ static float angle = 0.0f;
+ static double elapsed_time_sum = 0;
+ static double gpu_timer_elapsed_sum = 0;
+ static double start_time = NowInMs();
+
+ // After how many frames to report the avg frame time.
+ int kFrameReportInterval = 1;
+ static int frame_count = 0;
+
+ frame_count++;
+ if (frame_count == kFrameReportInterval) {
+ LOGI("%f\n", elapsed_time_sum / (double)kFrameReportInterval);
+
+ frame_count = 0;
+ elapsed_time_sum = 0;
+ gpu_timer_elapsed_sum = 0;
+ }
+
+ double current_time = NowInMs();
+ double elapsed_time = current_time - previous_time;
+ previous_time = current_time;
+ elapsed_time_sum += elapsed_time;
+ float global_time = (float)(NowInMs() - start_time);
+
+ glViewport(0, 0, g_framebuffer_width, g_framebuffer_height);
+
+ glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+ float fov = 45;
+
+ shader.PrepareForDraw(g_framebuffer_width, g_framebuffer_height, global_time, frame_count, (float)elapsed_time);
+
+ glBindVertexArray(g_quad_vao);
+
+ glDrawArrays(GL_TRIANGLES, 0, 6);
+}
+
+void Cleanup() {
+
+}
diff --git a/hostsidetests/sustainedperf/shadertoy_android/jni/shadertoy_shader.cpp b/hostsidetests/sustainedperf/shadertoy_android/jni/shadertoy_shader.cpp
new file mode 100644
index 0000000..c74876d
--- /dev/null
+++ b/hostsidetests/sustainedperf/shadertoy_android/jni/shadertoy_shader.cpp
@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "shadertoy_shader.h"
+#include "utils.h"
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+namespace {
+bool CompileShader10(GLuint shader, const std::string& shader_string) {
+ std::string prefix = "#version 100\n";
+ std::string string_with_prefix = prefix + shader_string;
+ const char* shader_str[] = { string_with_prefix.data() };
+ glShaderSource(shader, 1, shader_str, NULL);
+ glCompileShader(shader);
+
+ GLint success;
+ GLchar infoLog[512];
+ glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
+ if (!success)
+ {
+ glGetShaderInfoLog(shader, 512, NULL, infoLog);
+ LOGI("Shader Failed to compile: %s -- %s\n", *shader_str, infoLog);
+ return false;
+ }
+ return true;
+}
+}; // namespace
+
+
+ShadertoyShader::ShadertoyShader() :
+ uiResolution_(-1), uiGlobalTime_(-1), uiFrame_(-1), uiTimeDelta_(-1),
+ uiChannel0_(-1), unViewport_(-1), unCorners_(-1), shader_program_(0) {
+
+ GLuint tex_ids[4];
+ glGenTextures(4, &tex_ids[0]);
+ for (int ii = 0; ii < 4; ii++) {
+ input_textures_[ii].width = 0;
+ input_textures_[ii].height = 0;
+ input_textures_[ii].id = tex_ids[ii];
+ }
+}
+
+ShadertoyShader::~ShadertoyShader() {
+ GLuint ids[] = { input_textures_[0].id, input_textures_[1].id, input_textures_[2].id, input_textures_[3].id, };
+ glDeleteTextures(4, ids);
+}
+
+void ShadertoyShader::CreateShaderFromString(const std::string& shader_string) {
+ CreateShader(shader_string);
+}
+
+void ShadertoyShader::GetUniformLocations() {
+ glUseProgram(shader_program_);
+ uiResolution_ = glGetUniformLocation(shader_program_, "iResolution");
+ uiGlobalTime_ = glGetUniformLocation(shader_program_, "iGlobalTime");
+ uiFrame_ = glGetUniformLocation(shader_program_, "iFrame");
+ uiTimeDelta_ = glGetUniformLocation(shader_program_, "iTimeDelta");
+ uiChannel0_ = glGetUniformLocation(shader_program_, "iChannel0");
+
+ if (uiChannel0_ != -1)
+ glUniform1i(uiChannel0_, 0);
+
+ unViewport_ = glGetUniformLocation(shader_program_, "unViewport");
+ unCorners_ = glGetUniformLocation(shader_program_, "unCorners");
+
+ glUseProgram(0);
+}
+
+void ShadertoyShader::CreateShader(const std::string fragment_string) {
+ std::string vertex_string = SHADER0([]() {
+ attribute vec2 pos;
+ void main() {
+ gl_Position = vec4(pos.xy, 0.0, 1.0);
+ }
+ });
+
+ std::string shader_toy_fragment_header = SHADER0([]() {
+ precision highp float;
+ uniform vec3 iResolution;
+ uniform float iGlobalTime;
+ uniform vec4 iMouse;
+ uniform int iFrame;
+ uniform float iTimeDelta;
+ uniform vec3 iChannelResolution[4];
+ uniform sampler2D iChannel0;
+ vec4 texture2DGrad(sampler2D s, in vec2 uv, vec2 gx, vec2 gy) { return texture2D(s, uv); }
+ vec4 texture2DLod(sampler2D s, in vec2 uv, in float lod) { return texture2D(s, uv); }
+ void mainImage(out vec4 c, in vec2 f);
+ });
+
+ std::string shader_toy_fragment_footer = SHADER0([]() {
+ void main(void) {
+ vec4 shader_color = vec4(0, 0, 0, 1);
+ mainImage(shader_color, gl_FragCoord.xy);
+ shader_color.w = 1.0;
+ gl_FragColor = shader_color;
+ }
+ });
+
+ std::string complete_fragment_string = shader_toy_fragment_header + fragment_string + shader_toy_fragment_footer;
+
+ GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER);
+ CompileShader10(vertex_shader, vertex_string);
+
+ GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
+ CompileShader10(fragment_shader, complete_fragment_string);
+
+ // Link shaders
+ shader_program_ = glCreateProgram();
+ LinkProgram(shader_program_, vertex_shader, fragment_shader);
+
+ GetUniformLocations();
+
+ glDeleteShader(vertex_shader);
+ glDeleteShader(fragment_shader);
+}
+
+void ShadertoyShader::PrepareForDraw(int width, int height, float global_time, int frame, float time_delta) {
+ glUseProgram(shader_program_);
+
+ // Set the uniforms
+ if (uiResolution_ != -1)
+ glUniform3f(uiResolution_, (float)width, (float)height, 1);
+ if (uiGlobalTime_ != -1)
+ glUniform1f(uiGlobalTime_, global_time);
+ if (uiFrame_ != -1)
+ glUniform1f(uiFrame_, (float)frame);
+ if (uiTimeDelta_ != -1)
+ glUniform1f(uiTimeDelta_, time_delta);
+
+ glActiveTexture(GL_TEXTURE0);
+ glBindTexture(GL_TEXTURE_2D, input_textures_[0].id);
+ glActiveTexture(GL_TEXTURE1);
+ glBindTexture(GL_TEXTURE_2D, input_textures_[1].id);
+ glActiveTexture(GL_TEXTURE2);
+ glBindTexture(GL_TEXTURE_2D, input_textures_[2].id);
+ glActiveTexture(GL_TEXTURE3);
+ glBindTexture(GL_TEXTURE_2D, input_textures_[3].id);
+
+ if (unViewport_ != -1)
+ glUniform4f(unViewport_, 0, 0, (float)width, (float)height);
+}
diff --git a/hostsidetests/sustainedperf/shadertoy_android/jni/shadertoy_shader.h b/hostsidetests/sustainedperf/shadertoy_android/jni/shadertoy_shader.h
new file mode 100644
index 0000000..3823700
--- /dev/null
+++ b/hostsidetests/sustainedperf/shadertoy_android/jni/shadertoy_shader.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SHADERTOY_SHADER_H
+#define SHADERTOY_SHADER_H
+
+#include <GLES3/gl31.h>
+
+#include <fstream>
+#include <sstream>
+
+struct InputTextures {
+ GLuint id;
+ GLint uniform_location;
+ int width;
+ int height;
+};
+
+class ShadertoyShader {
+ public:
+ ShadertoyShader();
+ ~ShadertoyShader();
+
+ void CreateShaderFromString(const std::string& shader_string);
+ void PrepareForDraw(int width, int height, float global_time, int frame, float time_delta);
+
+ private:
+ void CreateShader(const std::string fragment_string);
+ void GetUniformLocations();
+
+ GLint uiResolution_;
+ GLint uiGlobalTime_;
+ GLint uiFrame_;
+ GLint uiTimeDelta_;
+ GLint uiChannel0_;
+ GLint unViewport_;
+ GLint unCorners_;
+
+ GLuint shader_program_;
+
+ struct InputTextures input_textures_[4];
+};
+
+
+
+#endif // SHADERTOY_SHADER_H
diff --git a/hostsidetests/sustainedperf/shadertoy_android/jni/utils.cpp b/hostsidetests/sustainedperf/shadertoy_android/jni/utils.cpp
new file mode 100644
index 0000000..41aab16
--- /dev/null
+++ b/hostsidetests/sustainedperf/shadertoy_android/jni/utils.cpp
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+#include "utils.h"
+
+float DegToRad(float deg) {
+ return deg * (float)M_PI / 180.0f;
+}
+
+bool CompileShader(GLuint shader, const std::string& shader_string) {
+ std::string prefix = "#version 300 es\n";
+ std::string string_with_prefix = prefix + shader_string;
+ const char* shader_str[] = { string_with_prefix.data() };
+ glShaderSource(shader, 1, shader_str, NULL);
+ glCompileShader(shader);
+
+ GLint success;
+ GLchar infoLog[512];
+ glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
+ if (!success)
+ {
+ glGetShaderInfoLog(shader, 512, NULL, infoLog);
+ LOGI("Shader Failed to compile: %s -- %s\n", *shader_str, infoLog);
+ return false;
+ }
+ return true;
+}
+
+bool LinkProgram(GLuint program, GLuint vertex_shader, GLuint fragment_shader) {
+ glAttachShader(program, vertex_shader);
+ glAttachShader(program, fragment_shader);
+ glLinkProgram(program);
+
+ // Check for linking errors
+ GLint success;
+ GLchar infoLog[512];
+ glGetProgramiv(program, GL_LINK_STATUS, &success);
+ if (!success) {
+ glGetProgramInfoLog(program, 512, NULL, infoLog);
+ LOGE("Shader failed to link: %s\n", infoLog);
+ return false;
+ }
+
+ return true;
+}
+
+GLenum GLCheckError() {
+ return GLCheckErrorStr("");
+}
+
+GLenum GLCheckErrorStr(std::string msg) {
+ GLenum e = glGetError();
+ std::string str;
+ if (e != GL_NO_ERROR) {
+ switch (e) {
+ case GL_INVALID_ENUM:
+ str = "GL_INVALID_ENUM";
+ break;
+ case GL_INVALID_OPERATION:
+ str = "GL_INVALID_OPERATION";
+ break;
+ case GL_INVALID_VALUE:
+ str = "GL_INVALID_VALUE";
+ break;
+ case GL_OUT_OF_MEMORY:
+ str = "GL_OUT_OF_MEMORY";
+ break;
+ case GL_INVALID_FRAMEBUFFER_OPERATION:
+ str = "GL_INVALID_FRAMEBUFFER_OPERATION";
+ break;
+ }
+ LOGE("OpenGL error : %s : %s (%#08x)\n", msg.c_str(), str.c_str(), e);
+ }
+ return e;
+}
diff --git a/hostsidetests/sustainedperf/shadertoy_android/jni/utils.h b/hostsidetests/sustainedperf/shadertoy_android/jni/utils.h
new file mode 100644
index 0000000..f14a9bf
--- /dev/null
+++ b/hostsidetests/sustainedperf/shadertoy_android/jni/utils.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef COMMON_UTILS_H
+#define COMMON_UTILS_H
+
+#include <math.h>
+#include <string>
+
+#include <android/log.h>
+
+#include <GLES3/gl31.h>
+#include <GLES3/gl3ext.h>
+
+#define LOG_TAG "GPUStressTestActivity"
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
+
+inline void PrintGLError(...) {
+ __android_log_print(ANDROID_LOG_ERROR,LOG_TAG, "GL_ERROR");
+}
+
+#ifdef LOG_GL_ERRORS
+#define GL_CALL(call) \
+ { \
+ call; \
+ if (glGetError() != GL_NO_ERROR) { \
+ PrintGLError(); \
+ } \
+ }
+#else
+#define GL_CALL(call) \
+ { \
+ call; \
+ }
+#endif
+
+template <size_t size>
+std::string StripLambda(const char(&shader)[size]) {
+ return std::string(shader + 6, shader + size - 2);
+}
+
+#define SHADER0(Src) StripLambda(#Src)
+
+bool CompileShader(GLuint shader, const std::string& shader_string);
+bool LinkProgram(GLuint program, GLuint vertex_shader, GLuint fragment_shader);
+
+// Converts from degrees to radians.
+float DegToRad(float deg);
+
+GLenum GLCheckError();
+GLenum GLCheckErrorStr(std::string str);
+
+#endif // COMMON_UTILS_H
diff --git a/hostsidetests/sustainedperf/shadertoy_android/res/values/strings.xml b/hostsidetests/sustainedperf/shadertoy_android/res/values/strings.xml
new file mode 100644
index 0000000..b6ebf69
--- /dev/null
+++ b/hostsidetests/sustainedperf/shadertoy_android/res/values/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+**
+** Copyright 2006, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+-->
+
+<!-- This file contains resource definitions for displayed strings, allowing
+ them to be changed based on the locale and options. -->
+
+<resources>
+ <!-- Simple strings. -->
+ <string name="gpustresstest_activity">GPUSTRESSTEST</string>
+
+</resources>
+
diff --git a/hostsidetests/sustainedperf/shadertoy_android/src/GLtestLib.java b/hostsidetests/sustainedperf/shadertoy_android/src/GLtestLib.java
new file mode 100644
index 0000000..f0a8dbf
--- /dev/null
+++ b/hostsidetests/sustainedperf/shadertoy_android/src/GLtestLib.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.gputest;
+
+// Wrapper for native library
+
+public class GLtestLib {
+
+ static {
+ System.loadLibrary("gltest");
+ }
+
+ /**
+ * @param width the current view width
+ * @param height the current view height
+ */
+ public static native void init(int width, int height);
+ public static native void step();
+}
diff --git a/hostsidetests/sustainedperf/shadertoy_android/src/GLtestView.java b/hostsidetests/sustainedperf/shadertoy_android/src/GLtestView.java
new file mode 100644
index 0000000..a6dab62
--- /dev/null
+++ b/hostsidetests/sustainedperf/shadertoy_android/src/GLtestView.java
@@ -0,0 +1,339 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.gputest;
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+import android.content.Context;
+import android.graphics.PixelFormat;
+import android.opengl.GLSurfaceView;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+
+import javax.microedition.khronos.egl.EGL10;
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.egl.EGLContext;
+import javax.microedition.khronos.egl.EGLDisplay;
+import javax.microedition.khronos.opengles.GL10;
+
+/**
+ * A simple GLSurfaceView sub-class that demonstrate how to perform
+ * OpenGL ES 2.0 rendering into a GL Surface. Note the following important
+ * details:
+ *
+ * - The class must use a custom context factory to enable 2.0 rendering.
+ * See ContextFactory class definition below.
+ *
+ * - The class must use a custom EGLConfigChooser to be able to select
+ * an EGLConfig that supports 2.0. This is done by providing a config
+ * specification to eglChooseConfig() that has the attribute
+ * EGL10.ELG_RENDERABLE_TYPE containing the EGL_OPENGL_ES2_BIT flag
+ * set. See ConfigChooser class definition below.
+ *
+ * - The class must select the surface's format, then choose an EGLConfig
+ * that matches it exactly (with regards to red/green/blue/alpha channels
+ * bit depths). Failure to do so would result in an EGL_BAD_MATCH error.
+ */
+class GLtestView extends GLSurfaceView {
+ private static String TAG = "GLtestView";
+ private static final boolean DEBUG = false;
+
+ public GLtestView(Context context) {
+ super(context);
+ init(false, 0, 0);
+ }
+
+ public GLtestView(Context context, boolean translucent, int depth, int stencil) {
+ super(context);
+ init(translucent, depth, stencil);
+ }
+
+ private void init(boolean translucent, int depth, int stencil) {
+
+ /* By default, GLSurfaceView() creates a RGB_565 opaque surface.
+ * If we want a translucent one, we should change the surface's
+ * format here, using PixelFormat.TRANSLUCENT for GL Surfaces
+ * is interpreted as any 32-bit surface with alpha by SurfaceFlinger.
+ */
+ if (translucent) {
+ this.getHolder().setFormat(PixelFormat.TRANSLUCENT);
+ }
+
+ /* Setup the context factory for 2.0 rendering.
+ * See ContextFactory class definition below
+ */
+ setEGLContextFactory(new ContextFactory());
+
+ /* We need to choose an EGLConfig that matches the format of
+ * our surface exactly. This is going to be done in our
+ * custom config chooser. See ConfigChooser class definition
+ * below.
+ */
+ setEGLConfigChooser( translucent ?
+ new ConfigChooser(8, 8, 8, 8, depth, stencil) :
+ new ConfigChooser(5, 6, 5, 0, depth, stencil) );
+
+ /* Set the renderer responsible for frame rendering */
+ setRenderer(new Renderer());
+ }
+
+ private static class ContextFactory implements GLSurfaceView.EGLContextFactory {
+ private static int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
+ public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig eglConfig) {
+ Log.w(TAG, "creating OpenGL ES 3.0 context");
+ checkEglError("Before eglCreateContext", egl);
+ int[] attrib_list = {EGL_CONTEXT_CLIENT_VERSION, 3, EGL10.EGL_NONE };
+ EGLContext context = egl.eglCreateContext(display, eglConfig, EGL10.EGL_NO_CONTEXT, attrib_list);
+ checkEglError("After eglCreateContext", egl);
+ return context;
+ }
+
+ public void destroyContext(EGL10 egl, EGLDisplay display, EGLContext context) {
+ egl.eglDestroyContext(display, context);
+ }
+ }
+
+ private static void checkEglError(String prompt, EGL10 egl) {
+ int error;
+ while ((error = egl.eglGetError()) != EGL10.EGL_SUCCESS) {
+ Log.e(TAG, String.format("%s: EGL error: 0x%x", prompt, error));
+ }
+ }
+
+ private static class ConfigChooser implements GLSurfaceView.EGLConfigChooser {
+
+ public ConfigChooser(int r, int g, int b, int a, int depth, int stencil) {
+ mRedSize = r;
+ mGreenSize = g;
+ mBlueSize = b;
+ mAlphaSize = a;
+ mDepthSize = depth;
+ mStencilSize = stencil;
+ }
+
+ /* This EGL config specification is used to specify 2.0 rendering.
+ * We use a minimum size of 4 bits for red/green/blue, but will
+ * perform actual matching in chooseConfig() below.
+ */
+ private static int EGL_OPENGL_ES2_BIT = 4;
+ private static int[] s_configAttribs2 =
+ {
+ EGL10.EGL_RED_SIZE, 4,
+ EGL10.EGL_GREEN_SIZE, 4,
+ EGL10.EGL_BLUE_SIZE, 4,
+ EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+ EGL10.EGL_NONE
+ };
+
+ public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {
+
+ /* Get the number of minimally matching EGL configurations
+ */
+ int[] num_config = new int[1];
+ egl.eglChooseConfig(display, s_configAttribs2, null, 0, num_config);
+
+ int numConfigs = num_config[0];
+
+ if (numConfigs <= 0) {
+ throw new IllegalArgumentException("No configs match configSpec");
+ }
+
+ /* Allocate then read the array of minimally matching EGL configs
+ */
+ EGLConfig[] configs = new EGLConfig[numConfigs];
+ egl.eglChooseConfig(display, s_configAttribs2, configs, numConfigs, num_config);
+
+ if (DEBUG) {
+ printConfigs(egl, display, configs);
+ }
+ /* Now return the "best" one
+ */
+ return chooseConfig(egl, display, configs);
+ }
+
+ public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display,
+ EGLConfig[] configs) {
+ for(EGLConfig config : configs) {
+ int d = findConfigAttrib(egl, display, config,
+ EGL10.EGL_DEPTH_SIZE, 0);
+ int s = findConfigAttrib(egl, display, config,
+ EGL10.EGL_STENCIL_SIZE, 0);
+
+ // We need at least mDepthSize and mStencilSize bits
+ if (d < mDepthSize || s < mStencilSize)
+ continue;
+
+ // We want an *exact* match for red/green/blue/alpha
+ int r = findConfigAttrib(egl, display, config,
+ EGL10.EGL_RED_SIZE, 0);
+ int g = findConfigAttrib(egl, display, config,
+ EGL10.EGL_GREEN_SIZE, 0);
+ int b = findConfigAttrib(egl, display, config,
+ EGL10.EGL_BLUE_SIZE, 0);
+ int a = findConfigAttrib(egl, display, config,
+ EGL10.EGL_ALPHA_SIZE, 0);
+
+ if (r == mRedSize && g == mGreenSize && b == mBlueSize && a == mAlphaSize)
+ return config;
+ }
+ return null;
+ }
+
+ private int findConfigAttrib(EGL10 egl, EGLDisplay display,
+ EGLConfig config, int attribute, int defaultValue) {
+
+ if (egl.eglGetConfigAttrib(display, config, attribute, mValue)) {
+ return mValue[0];
+ }
+ return defaultValue;
+ }
+
+ private void printConfigs(EGL10 egl, EGLDisplay display,
+ EGLConfig[] configs) {
+ int numConfigs = configs.length;
+ Log.w(TAG, String.format("%d configurations", numConfigs));
+ for (int i = 0; i < numConfigs; i++) {
+ Log.w(TAG, String.format("Configuration %d:\n", i));
+ printConfig(egl, display, configs[i]);
+ }
+ }
+
+ private void printConfig(EGL10 egl, EGLDisplay display,
+ EGLConfig config) {
+ int[] attributes = {
+ EGL10.EGL_BUFFER_SIZE,
+ EGL10.EGL_ALPHA_SIZE,
+ EGL10.EGL_BLUE_SIZE,
+ EGL10.EGL_GREEN_SIZE,
+ EGL10.EGL_RED_SIZE,
+ EGL10.EGL_DEPTH_SIZE,
+ EGL10.EGL_STENCIL_SIZE,
+ EGL10.EGL_CONFIG_CAVEAT,
+ EGL10.EGL_CONFIG_ID,
+ EGL10.EGL_LEVEL,
+ EGL10.EGL_MAX_PBUFFER_HEIGHT,
+ EGL10.EGL_MAX_PBUFFER_PIXELS,
+ EGL10.EGL_MAX_PBUFFER_WIDTH,
+ EGL10.EGL_NATIVE_RENDERABLE,
+ EGL10.EGL_NATIVE_VISUAL_ID,
+ EGL10.EGL_NATIVE_VISUAL_TYPE,
+ 0x3030, // EGL10.EGL_PRESERVED_RESOURCES,
+ EGL10.EGL_SAMPLES,
+ EGL10.EGL_SAMPLE_BUFFERS,
+ EGL10.EGL_SURFACE_TYPE,
+ EGL10.EGL_TRANSPARENT_TYPE,
+ EGL10.EGL_TRANSPARENT_RED_VALUE,
+ EGL10.EGL_TRANSPARENT_GREEN_VALUE,
+ EGL10.EGL_TRANSPARENT_BLUE_VALUE,
+ 0x3039, // EGL10.EGL_BIND_TO_TEXTURE_RGB,
+ 0x303A, // EGL10.EGL_BIND_TO_TEXTURE_RGBA,
+ 0x303B, // EGL10.EGL_MIN_SWAP_INTERVAL,
+ 0x303C, // EGL10.EGL_MAX_SWAP_INTERVAL,
+ EGL10.EGL_LUMINANCE_SIZE,
+ EGL10.EGL_ALPHA_MASK_SIZE,
+ EGL10.EGL_COLOR_BUFFER_TYPE,
+ EGL10.EGL_RENDERABLE_TYPE,
+ 0x3042 // EGL10.EGL_CONFORMANT
+ };
+ String[] names = {
+ "EGL_BUFFER_SIZE",
+ "EGL_ALPHA_SIZE",
+ "EGL_BLUE_SIZE",
+ "EGL_GREEN_SIZE",
+ "EGL_RED_SIZE",
+ "EGL_DEPTH_SIZE",
+ "EGL_STENCIL_SIZE",
+ "EGL_CONFIG_CAVEAT",
+ "EGL_CONFIG_ID",
+ "EGL_LEVEL",
+ "EGL_MAX_PBUFFER_HEIGHT",
+ "EGL_MAX_PBUFFER_PIXELS",
+ "EGL_MAX_PBUFFER_WIDTH",
+ "EGL_NATIVE_RENDERABLE",
+ "EGL_NATIVE_VISUAL_ID",
+ "EGL_NATIVE_VISUAL_TYPE",
+ "EGL_PRESERVED_RESOURCES",
+ "EGL_SAMPLES",
+ "EGL_SAMPLE_BUFFERS",
+ "EGL_SURFACE_TYPE",
+ "EGL_TRANSPARENT_TYPE",
+ "EGL_TRANSPARENT_RED_VALUE",
+ "EGL_TRANSPARENT_GREEN_VALUE",
+ "EGL_TRANSPARENT_BLUE_VALUE",
+ "EGL_BIND_TO_TEXTURE_RGB",
+ "EGL_BIND_TO_TEXTURE_RGBA",
+ "EGL_MIN_SWAP_INTERVAL",
+ "EGL_MAX_SWAP_INTERVAL",
+ "EGL_LUMINANCE_SIZE",
+ "EGL_ALPHA_MASK_SIZE",
+ "EGL_COLOR_BUFFER_TYPE",
+ "EGL_RENDERABLE_TYPE",
+ "EGL_CONFORMANT"
+ };
+ int[] value = new int[1];
+ for (int i = 0; i < attributes.length; i++) {
+ int attribute = attributes[i];
+ String name = names[i];
+ if ( egl.eglGetConfigAttrib(display, config, attribute, value)) {
+ Log.w(TAG, String.format(" %s: %d\n", name, value[0]));
+ } else {
+ // Log.w(TAG, String.format(" %s: failed\n", name));
+ while (egl.eglGetError() != EGL10.EGL_SUCCESS);
+ }
+ }
+ }
+
+ // Subclasses can adjust these values:
+ protected int mRedSize;
+ protected int mGreenSize;
+ protected int mBlueSize;
+ protected int mAlphaSize;
+ protected int mDepthSize;
+ protected int mStencilSize;
+ private int[] mValue = new int[1];
+ }
+
+ private static class Renderer implements GLSurfaceView.Renderer {
+ public void onDrawFrame(GL10 gl) {
+ GLtestLib.step();
+ }
+
+ public void onSurfaceChanged(GL10 gl, int width, int height) {
+ GLtestLib.init(width, height);
+ }
+
+ public void onSurfaceCreated(GL10 gl, EGLConfig config) {
+ // Do nothing.
+ }
+ }
+}
diff --git a/hostsidetests/sustainedperf/shadertoy_android/src/GPUStressTestActivity.java b/hostsidetests/sustainedperf/shadertoy_android/src/GPUStressTestActivity.java
new file mode 100644
index 0000000..c135d9d
--- /dev/null
+++ b/hostsidetests/sustainedperf/shadertoy_android/src/GPUStressTestActivity.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.gputest;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.WindowManager;
+import java.io.File;
+
+
+public class GPUStressTestActivity extends Activity {
+
+ GLtestView mView;
+
+ @Override protected void onCreate(Bundle icicle) {
+ super.onCreate(icicle);
+ Bundle b = this.getIntent().getExtras();
+ getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+ if (b != null) {
+ boolean value = b.getBoolean("SustainedPerformanceMode");
+ if (value) {
+ getWindow().setSustainedPerformanceMode(true);
+ }
+ }
+ mView = new GLtestView(getApplication());
+ setContentView(mView);
+ }
+
+ @Override protected void onPause() {
+ super.onPause();
+ mView.onPause();
+ }
+
+ @Override protected void onResume() {
+ super.onResume();
+ mView.onResume();
+ }
+}
diff --git a/hostsidetests/sustainedperf/src/android/SustainedPerformance/cts/SustainedPerformanceHostTest.java b/hostsidetests/sustainedperf/src/android/SustainedPerformance/cts/SustainedPerformanceHostTest.java
new file mode 100644
index 0000000..0035f8e
--- /dev/null
+++ b/hostsidetests/sustainedperf/src/android/SustainedPerformance/cts/SustainedPerformanceHostTest.java
@@ -0,0 +1,247 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.sustainedPerformance.cts;
+
+import com.android.ddmlib.MultiLineReceiver;
+import com.android.ddmlib.IShellOutputReceiver;
+import com.android.tradefed.device.ITestDevice;
+import com.android.tradefed.testtype.DeviceTestCase;
+import com.android.ddmlib.Log;
+import java.util.Scanner;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.concurrent.TimeUnit;
+import java.util.*;
+/**
+ * Test to check if device implements Sustained Performance Mode
+ */
+public class SustainedPerformanceHostTest extends DeviceTestCase {
+
+ ITestDevice device;
+ private static final String PACKAGE = "com.android.gputest";
+ private static final String CLASS = "GPUStressTestActivity";
+ private static final String START_COMMAND = String.format(
+ "am start -W -a android.intent.action.MAIN -n %s/%s.%s",
+ PACKAGE, PACKAGE, CLASS);
+ private static final String START_COMMAND_MODE = String.format(
+ "am start -W -a android.intent.action.MAIN -n %s/%s.%s --ez SustainedPerformanceMode true",
+ PACKAGE, PACKAGE, CLASS);
+ private static final String STOP_COMMAND = String.format(
+ "am force-stop %s", PACKAGE);
+ private static final String TEST_PACKAGE = "android.test.app";
+ private static final String TEST_CLASS = "DeviceTestActivity";
+ private static final String START_TEST_COMMAND = String.format(
+ "am start -W -a android.intent.action.MAIN -n %s/%s.%s",
+ TEST_PACKAGE, TEST_PACKAGE, TEST_CLASS);
+ private static final String DHRYSTONE = "/data/local/tmp/";
+ private static final String LOG_TAG = "sustainedPerfTest";
+
+ private static ArrayList<Double> appResultsWithMode = new ArrayList<Double>();
+ private static ArrayList<Double> appResultsWithoutMode = new ArrayList<Double>();
+ private static ArrayList<Double> dhrystoneResultsWithMode = new ArrayList<Double>();
+ private static ArrayList<Double> dhrystoneResultsWithoutMode = new ArrayList<Double>();
+ private double dhryMin = Double.MAX_VALUE, dhryMax = Double.MIN_VALUE;
+ private static long testDuration = 1800000; //30 minutes
+
+ public class Dhrystone implements Runnable {
+ private boolean modeEnabled;
+ private long startTime;
+ private long loopCount = 3000000;
+
+ public Dhrystone(boolean enabled) {
+ modeEnabled = enabled;
+ startTime = System.currentTimeMillis();
+ }
+
+ public void run() {
+ double[] testSet = new double[3];
+ int index = 0;
+ try {
+ device.executeShellCommand("cd " + DHRYSTONE + " ; chmod 777 dhry");
+ while (true) {
+ String result = device.executeShellCommand("echo " + loopCount + " | " + DHRYSTONE + "dhry");
+ if (Math.abs(System.currentTimeMillis() - startTime) >= testDuration) {
+ break;
+ } else if (result.contains("Measured time too small")) {
+ loopCount = loopCount*10;
+ } else if (!result.isEmpty()){
+ double dmips = Double.parseDouble(result);
+ testSet[index++] = dmips;
+ if (index == 3) {
+ synchronized(this) {
+ if (modeEnabled) {
+ dhrystoneResultsWithMode.add(testSet[1]);
+ } else {
+ dhrystoneResultsWithoutMode.add(testSet[1]);
+ }
+ if (testSet[1] > dhryMax) {
+ dhryMax = testSet[1];
+ }
+ if (testSet[1] < dhryMin) {
+ dhryMin = testSet[1];
+ }
+ index = 0;
+ }
+ }
+ }
+ }
+ } catch (Exception e) {
+ Log.e(LOG_TAG, e.toString());
+
+ }
+ }
+ }
+
+ public void analyzeResults(String logs, boolean mode) {
+ Double[] testSet = new Double[10];
+ int index = 0;
+ double min = Double.MAX_VALUE, max = Double.MIN_VALUE;
+
+ Scanner in = new Scanner(logs);
+ while (in.hasNextLine()) {
+ String line = in.nextLine();
+ if(line.startsWith("I/"+CLASS)) {
+ Double time = Double.parseDouble(line.split(":")[1]);
+ testSet[index++] = time;
+ if (index == 10) {
+ Arrays.sort(testSet);
+ if (mode) {
+ appResultsWithMode.add(testSet[5]);
+ } else {
+ appResultsWithoutMode.add(testSet[5]);
+ }
+ if (testSet[5] > max) {
+ max = testSet[5];
+ }
+ if (testSet[5] < min) {
+ min = testSet[5];
+ }
+ index = 0;
+ }
+ }
+ }
+ in.close();
+ double diff = (max - min)*100/max;
+ if (mode) {
+ appResultsWithMode.add(0, min);
+ appResultsWithMode.add(1, max);
+ appResultsWithMode.add(2, diff);
+ } else {
+ appResultsWithoutMode.add(0, min);
+ appResultsWithoutMode.add(1, max);
+ appResultsWithoutMode.add(2, diff);
+ }
+ }
+
+ private void setUpEnvironment() throws Exception {
+ device.disconnectFromWifi();
+ dhryMin = Double.MAX_VALUE;
+ dhryMax = Double.MIN_VALUE;
+ Thread.sleep(600000);
+ device.executeAdbCommand("logcat", "-c");
+ device.executeShellCommand("settings put global airplane_mode_on 1");
+ device.executeShellCommand("am broadcast -a android.intent.action.AIRPLANE_MODE --ez state true");
+ }
+
+ public void testShader() throws Exception {
+ device = getDevice();
+
+ /**
+ * Check if the device supports Sustained Performance Mode.
+ * If not then assert true and return.
+ **/
+ device.executeAdbCommand("logcat", "-c");
+ device.executeShellCommand(START_TEST_COMMAND);
+ String logs = device.executeAdbCommand("logcat", "-v", "brief", "-d", TEST_CLASS + ":I", "*:S");
+ String testString = "";
+ Scanner in = new Scanner(logs);
+ while (in.hasNextLine()) {
+ String line = in.nextLine();
+ if(line.startsWith("I/"+TEST_CLASS)) {
+ testString = line.split(":")[1].trim();
+ }
+ }
+ in.close();
+ if (testString.isEmpty()) {
+ assertTrue(true);
+ return;
+ }
+
+ appResultsWithoutMode.clear();
+ appResultsWithMode.clear();
+ dhrystoneResultsWithoutMode.clear();
+ dhrystoneResultsWithMode.clear();
+
+ /*
+ * Run the test without the mode.
+ * Start the application and collect stats.
+ * Run two threads of dhrystone and collect stats.
+ */
+ setUpEnvironment();
+ device.executeShellCommand(START_COMMAND);
+ Thread dhrystone = new Thread(new Dhrystone(false));
+ Thread dhrystone1 = new Thread(new Dhrystone(false));
+ dhrystone.start();
+ dhrystone1.start();
+ Thread.sleep(testDuration);
+ device.executeShellCommand(STOP_COMMAND);
+ dhrystone.join();
+ dhrystone1.join();
+ logs = device.executeAdbCommand("logcat", "-v", "brief", "-d", CLASS + ":I", "*:S");
+ analyzeResults(logs, false);
+ double diff = (dhryMax - dhryMin)*100/dhryMax;
+ dhrystoneResultsWithoutMode.add(0, dhryMin);
+ dhrystoneResultsWithoutMode.add(1, dhryMax);
+ dhrystoneResultsWithoutMode.add(2, diff);
+
+ /*
+ * Run the test with the mode.
+ * Start the application and collect stats.
+ * Run two threads of dhrystone and collect stats.
+ */
+ setUpEnvironment();
+ device.executeShellCommand(START_COMMAND_MODE);
+ dhrystone = new Thread(new Dhrystone(true));
+ dhrystone1 = new Thread(new Dhrystone(true));
+ dhrystone.start();
+ dhrystone1.start();
+ Thread.sleep(testDuration);
+ device.executeShellCommand(STOP_COMMAND);
+ dhrystone.join();
+ dhrystone1.join();
+ logs = device.executeAdbCommand("logcat", "-v", "brief", "-d", CLASS + ":I", "*:S");
+ analyzeResults(logs, true);
+ diff = (dhryMax - dhryMin)*100/dhryMax;
+ dhrystoneResultsWithMode.add(0, dhryMin);
+ dhrystoneResultsWithMode.add(1, dhryMax);
+ dhrystoneResultsWithMode.add(2, diff);
+
+ device.executeShellCommand("settings put global airplane_mode_on 0");
+ device.executeShellCommand("am broadcast -a android.intent.action.AIRPLANE_MODE --ez state false");
+
+ double perfdegradapp = (appResultsWithMode.get(1) - appResultsWithoutMode.get(1))*100/appResultsWithMode.get(1);
+ double perfdegraddhry = (dhrystoneResultsWithoutMode.get(0) - dhrystoneResultsWithMode.get(0))*100/dhrystoneResultsWithoutMode.get(0);
+
+ /*
+ * Checks if the performance in the mode is consistent with
+ * 5% error margin.
+ */
+ assertFalse("Results in the mode are not sustainable",
+ (dhrystoneResultsWithMode.get(2) > 5) ||
+ (appResultsWithMode.get(2)) > 5);
+ }
+}
diff --git a/tests/tests/view/src/android/view/cts/ViewTest.java b/tests/tests/view/src/android/view/cts/ViewTest.java
index 3f213be..7d11c68 100644
--- a/tests/tests/view/src/android/view/cts/ViewTest.java
+++ b/tests/tests/view/src/android/view/cts/ViewTest.java
@@ -385,8 +385,7 @@
public void testAccessPointerIcon() {
View view = mActivity.findViewById(R.id.pointer_icon_layout);
- MotionEvent event = MotionEvent.obtain(0, 0, MotionEvent.ACTION_HOVER_MOVE,
- view.getX(), view.getY(), 0);
+ MotionEvent event = MotionEvent.obtain(0, 0, MotionEvent.ACTION_HOVER_MOVE, 0, 0, 0);
// First view has pointerIcon="help"
assertEquals(PointerIcon.getSystemIcon(mActivity, PointerIcon.TYPE_HELP),
diff --git a/tests/tests/widget/src/android/widget/cts/TextViewTest.java b/tests/tests/widget/src/android/widget/cts/TextViewTest.java
index 4a709dd..35b7851 100644
--- a/tests/tests/widget/src/android/widget/cts/TextViewTest.java
+++ b/tests/tests/widget/src/android/widget/cts/TextViewTest.java
@@ -2663,7 +2663,6 @@
});
getInstrumentation().waitForIdleSync();
- assertEquals(tvEllipsizeEnd.getLineCount(), tvEllipsizeNone.getLineCount());
for (int i = 0; i < tvEllipsizeEnd.getLineCount(); i++) {
assertEquals("Ellipsized and non ellipsized multi line texts should have the same " +
"baseline for line " + i,