Buildable under Android (monkins1010#6)

* Include missing pthreads barrier functions, if Android version is less than 24;
Also barrier functions renamed for skip naming collisions

* Updated Makefile.am, configure.sh and utils.cpp to support Android

* Skip pthread_setcanceltype if under Android < 24

* Updated config.guess to the latest version

* Android < 23 doesn't support thread affinity

* Include sys/endian.h if Android

* Added build instructions on Android

* Android readme updated: added command to patch gcc before build

* Beautify the readme

* Fixed README-ANDROID.md

* Fixed README-ANDROID

* Updated android readme

* Fixed builds on Android 24+

* Readme updated

* Fixed warnings and undefined behavior (possible overflow bug) in haraka logic

Author: shmutalov

Makefile.am

@@ -40,6 +40,8 @@ ccminer_LDFLAGS += -L/usr/local/llvm/lib
 ccminer_LDADD += -lomp
 endif
 
-
+if HAVE_ANDROID
+ccminer_LDADD += -llog
+endif
 
 

README-ANDROID.md

@@ -0,0 +1,62 @@
+**How to compile on Android**
+
+*NOTE: Tested on rooted Android 6*
+
+There are two methods (or more?), to compile `ccminer` on Android:
+
+1. By installing a Linux distribution with help of `Termux` + `proot-distro`: https://medium.com/veruscoin/mining-veruscoin-on-smartphone-208dbb06905f
+2. By compiling without the any Linux distribution, purely on the system. 
+
+This document explains the second way.
+
+# Step 1 - Install the Termux
+
+Download and install the [Termux](https://play.google.com/store/apps/details?id=com.termux) application.
+Open the Termux after install. Next steps we need to do inside it.
+
+# Step 2 - Install the dependency packages
+
+Run following command, to install the development dependencies:
+
+`pkg install automake build-essential curl git gnupg openssl nano`
+
+# Step 3 - Install a GCC 
+
+I can't build the `ccminer` with `clang` that default compiler which comes with `Termux` (and Termux makes `clang` as alias for `gcc`). 
+Also, Termux deprecated a _real_ gcc compiler tools, so we need to use [Its-Pointless Termux repo](https://github.com/its-pointless/gcc_termux), to install gcc from it.
+
+Run the following command, to set-up _Its-Pointless Termux Repo_:
+
+`curl -s https://its-pointless.github.io/setup-pointless-repo.sh | bash`
+
+Then we need to install `gcc-6` (or `gcc-7`, `gcc-8`, `gcc-9`, `gcc-10`) package:
+
+`pkg install gcc-6`
+
+(or `pkg install gcc-7`, `pkg install gcc-8`, `pkg install gcc-9`, `pkg install gcc-10`, it depends on the Android version you are running)
+
+# Step 4 - Build
+
+Clone the `ccminer` git repo (`ARM` branch):
+
+`git clone --single-branch -b ARM https://github.com/shmutalov/ccminer.git`
+
+Then change the current directory:
+
+`cd ccminer`
+
+To build `ccminer` from sources we need to switch the default `clang` compiler to the `gcc` we installed on step 3 by executing following commands:
+
+`setupgcc-6`
+
+(or `setupgcc-7`, `setupgcc-8`, `setupgcc-9`, `setupgcc-10`)
+
+and then (to make `configure` process happy)
+
+`setup-patchforgcc`
+
+Then start the build:
+
+`./build.sh`
+
+After successful build you can run built `ccminer` binary file to start the mining

README.md

@@ -34,3 +34,8 @@ Compile on Linux
 ----------------
 
 Please see [INSTALL](https://github.com/tpruvot/ccminer/blob/linux/INSTALL) file or [project Wiki](https://github.com/tpruvot/ccminer/wiki/Compatibility)
+
+Compile on Android
+------------------
+
+Please see [README-ANDROID](./README-ANDROID.md) file

api.cpp

@@ -1077,7 +1077,10 @@ static void *mcast_thread(void *userdata)
 	struct thr_info *mythr = (struct thr_info *)userdata;
 
 	pthread_detach(pthread_self());
+
+#if !(defined(__ANDROID__) || (__ANDROID_API__ > 23))
 	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
+#endif
 
 	mcast();
 

bench.cpp

@@ -9,8 +9,12 @@
 #include "miner.h"
 #include "algos.h"
 
-#ifdef __APPLE__
+#if defined(__APPLE__) || (defined(__ANDROID__) && (__ANDROID_API__ < 24))
 #include "compat/pthreads/pthread_barrier.hpp"
+#else
+#define pthread_barrier_init_ pthread_barrier_init
+#define pthread_barrier_destroy_ pthread_barrier_destroy
+#define pthread_barrier_wait_ pthread_barrier_wait
 #endif
 
 int bench_algo = -1;
@@ -30,16 +34,16 @@ void bench_init(int threads)
 {
 	bench_algo = opt_algo = (enum sha_algos) 0; /* first */
 	applog(LOG_BLUE, "Starting benchmark mode with %s", algo_names[opt_algo]);
-	pthread_barrier_init(&miner_barr, NULL, threads);
-	pthread_barrier_init(&algo_barr, NULL, threads);
+	pthread_barrier_init_(&miner_barr, NULL, threads);
+	pthread_barrier_init_(&algo_barr, NULL, threads);
 	// required for usage of first algo.
 
 }
 
 void bench_free()
 {
-	pthread_barrier_destroy(&miner_barr);
-	pthread_barrier_destroy(&algo_barr);
+	pthread_barrier_destroy_(&miner_barr);
+	pthread_barrier_destroy_(&algo_barr);
 }
 
 // required to switch algos
@@ -104,7 +108,7 @@ bool bench_algo_switch_next(int thr_id)
 
 	// we need to wait completion on all cards before the switch
 	if (opt_n_threads > 1) {
-		pthread_barrier_wait(&miner_barr);
+		pthread_barrier_wait_(&miner_barr);
 	}
 
 	char rate[32] = { 0 };
@@ -126,7 +130,7 @@ bool bench_algo_switch_next(int thr_id)
 
 	// wait the other threads to display logs correctly
 	if (opt_n_threads > 1) {
-		pthread_barrier_wait(&algo_barr);
+		pthread_barrier_wait_(&algo_barr);
 	}
 
 	if (algo == ALGO_AUTO)

ccminer.cpp

@@ -547,7 +547,11 @@ static void affine_to_cpu_mask(int id, unsigned long mask) {
 		sched_setaffinity(0, sizeof(&set), &set);
 	} else {
 		// thread only
+#if !(defined(__ANDROID__) || (__ANDROID_API__ > 23))
 		pthread_setaffinity_np(thr_info[id].pth, sizeof(&set), &set);
+#else
+		sched_setaffinity(0, sizeof(&set), &set);
+#endif
 	}
 }
 #elif defined(__FreeBSD__) /* FreeBSD specific policy and affinity management */

compat/pthreads/pthread_barrier.hpp

@@ -18,7 +18,7 @@ typedef struct
 } pthread_barrier_t;
 
 
-int pthread_barrier_init(pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count)
+int pthread_barrier_init_(pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count)
 {
     if(count == 0)
     {
@@ -40,14 +40,14 @@ int pthread_barrier_init(pthread_barrier_t *barrier, const pthread_barrierattr_t
     return 0;
 }
 
-int pthread_barrier_destroy(pthread_barrier_t *barrier)
+int pthread_barrier_destroy_(pthread_barrier_t *barrier)
 {
     pthread_cond_destroy(&barrier->cond);
     pthread_mutex_destroy(&barrier->mutex);
     return 0;
 }
 
-int pthread_barrier_wait(pthread_barrier_t *barrier)
+int pthread_barrier_wait_(pthread_barrier_t *barrier)
 {
     pthread_mutex_lock(&barrier->mutex);
     ++(barrier->count);