Download/compile/execute
RaceConditionRandomSeederR2d0BitsetImpl.cpp
wget www.heteroclinic.net/attached/RaceConditionRandomSeederR2d0BitsetImpl.cpp g++ -o RaceConditionRandomSeederR2d0BitsetImpl.exe RaceConditionRandomSeederR2d0BitsetImpl.cpp -lpthread ./RaceConditionRandomSeederR2d0BitsetImpl.exe

/* Science and technology promotion license applied (third-party licenses/rights auto-cascaded, free usage of this program for non-commercial purposes, the liability of Zhikai Wang/ www.heteroclinic.net is to remove/modify matters in dispute) (c) Zhikai Wang/ www.heteroclinic.net 2013 */ /* Introduction: Race Condition Random Seeder Release is a tool aiming to create random seeds for random generators. It utilizes modern computer systems' high frequency CPU clock and multitasking in paralell features. By creating man-made race condition, we retrieve a volatile boolean value that threads race upon. The values retrieved thus form a bit-bundle representing a numerical value. We can say, we can achieve to some degree true random, or software random, in an isolated system. Such system is like modern computer system, having two or more independent computing units. So I may say you may let a computer do something all by itself, in some degree (to a great degree) independent of the environment. In this release R-2.2, we tried to repeat the same principle we did in C/C++ in Java. The effect is not quite satisfying by observation. In my experiments, we have to force the threads sleep/context switch to add the entropy. Mainly, this should relate particularly to JVM thread slicing settings. By observation, it causes a single thread dominate the shared flip. In C++/C test, forcing threads to sleep/context switch thus yielding each other is not necessary. We have to mention, the particular setting shown as below worked at a particular combo of OS, JVM and hardware. You can tune the parameters so the results can be statistically satisfying. Note: forcing the threads to sleep/context switch thus yielding each other significantly drags down the performance. In contrast in C++/C test, forcing threads to sleep/context switch thus yielding each other is not necessary (but again, it is a given combo of conditions). Again, you can find some key parameters to tune with by studying the source code. This program due to its nature will not be of high performance. It is suggested to be used as a seeder program for other random generators, e.g. linear congruential random generator etc. */ import java.util.ArrayList; import java.util.BitSet; import java.util.List; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicLong; public class RaceConditionRandomSeederR2d2JavaImpl { public static final int nooftasks =4; // In my experiments, we have to force the threads sleep/context switch to add the entropy. // Mainly, this should relate particularly to JVM thread slicing settings. By observation, it causes a single thread dominate the shared flip. // In C++/C test, forcing threads to sleep/context switch thus yielding each other is not necessary. // We have to mention, for the particular setting as below, worked at a particular combo of OS, JVM and hardware. // We can say, we can achieve to some degree true random, or software random, in an isolated system. // Such system is like modern computer system, having two or more independent computing units. // So I may say you may let a computer do something all by itself, in some degree (to a great degree) independent of the environment. // You can tune the parameters so the results can be statistically satisfying. // Note: forcing the threads to sleep/context switch thus yielding each other significantly drags down the performance. // In C++/C test, forcing threads to sleep/context switch thus yielding each other is not necessary. public static final long racerSlice = 10l; //Micro seconds public static final long anchorSlice = 100l; //Micro seconds public static CountDownLatch latch = new CountDownLatch(nooftasks); public static volatile boolean shared = false; protected static List <String > results ; public static synchronized List <String > getResults(){ if (null == results) results = new ArrayList<String>(); return results; } public static String incarnateBitsetviaByte (BitSet bs, String separator) { return incarnateBitsetviaByte (bs, separator, -1); } public static String incarnateBitsetviaByte (BitSet bs, String separator,int totalBytesUseingForAlign) { String result =""; int i = 0; byte[] barr = bs.toByteArray(); if (separator != null && separator.length() > 0) { for (i=barr.length-1; i>=0; i--) { String str = Integer.toBinaryString( 0xff & barr[i]); result += str.length()<Byte.SIZE ? String.format("%"+Byte.SIZE+"s", str).replace(' ', '0'): str; result += separator; } //remove trailing separator if (barr.length >= 2 && result.substring(result.length() - separator.length(), result.length()).equals(separator)) { result = result.substring(0,result.length() - separator.length()); } } else { for (i=barr.length-1; i>=0; i--) { String str = Integer.toBinaryString( 0xff & barr[i]); result += str.length()<Byte.SIZE ? String.format("%"+Byte.SIZE+"s", str).replace(' ', '0'): str; } } if (totalBytesUseingForAlign <=barr.length ) return result; else { String larger = ""; if (separator != null && separator.length() > 0) { for (i=0; i< totalBytesUseingForAlign; i++) { String str = Integer.toBinaryString( 0); larger += str.length()<Byte.SIZE ? String.format("%"+Byte.SIZE+"s", str).replace(' ', '0'): str; larger += separator; } if ( totalBytesUseingForAlign >= 2 && larger.substring(larger.length() - separator.length(), larger.length()).equals(separator)) { larger = larger.substring(0,larger.length() - separator.length()); } } else { for (i=0; i< totalBytesUseingForAlign; i++) { String str = Integer.toBinaryString( 0); larger += str.length()<Byte.SIZE ? String.format("%"+Byte.SIZE+"s", str).replace(' ', '0'): str; } } String part1 = larger.substring(0, larger.length() - result.length()); return part1 + result; } } static class Shared { public static volatile boolean halted = false; } static class Task implements Runnable { static AtomicLong taskCount = new AtomicLong(0); protected volatile boolean stopRequested = false ; public boolean isStopRequested() { return stopRequested; } public void setStopRequested(boolean stopRequested) { this.stopRequested = stopRequested; } protected long ID; public Task() { this.ID = taskCount.incrementAndGet(); } @Override public void run() { latch.countDown(); try { latch.await(); // while ( !Shared.halted && !Thread.interrupted() && !this.stopRequested) { try { TimeUnit.MICROSECONDS.sleep(racerSlice); } catch (InterruptedException e) { // e.printStackTrace(); } //Shared.shared = !Shared.shared; shared = !shared; // this effect is bad //shared = (this.ID %2 ==0); } } catch (InterruptedException e) { System.out.println(""+this.ID +" interrupted."); } finally { reachedBottom = true; if (this.stopRequested ) System.out.println(""+this.ID+" end"); } } protected volatile boolean reachedBottom; } /** * @param args. If args.length >= 2, args[0] represents bit-length, * args[1] represents the number of bit-bundles you need. * You can call the main directly in Another function. * Like RaceConditionRandomSeederR2d2JavaImpl.main(64,1024), then access * the public static List<String> results which buffered the bits bundles. */ public static void main(String[] args) { int bundleLength = 128; int totalBundles = 64; try { if (args.length >= 2) { bundleLength = Integer.parseInt(args[0]); totalBundles = Integer.parseInt(args[1]); } } catch (Exception e) { bundleLength = 64; totalBundles = 32; } List<Task> tasks = new ArrayList<Task>(); List<Future<?>> fl = new ArrayList<Future<?>>(); ExecutorService exec = Executors.newCachedThreadPool(); for (int i = 0; i < nooftasks; i++) { tasks.add(new Task()); } for (Task t : tasks) { fl.add(exec.submit(t)); } try { latch.await(); } catch (InterruptedException e) { e.printStackTrace(); } try { TimeUnit.MICROSECONDS.sleep(1000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } for (int i = 0; i < totalBundles; i++) { BitSet bs = new BitSet(); for (int j = 0 ; j < bundleLength; j++) { try { TimeUnit.MICROSECONDS.sleep(anchorSlice); } catch (InterruptedException e) { // e.printStackTrace(); } bs.set(j,shared); } getResults().add(incarnateBitsetviaByte(bs,"-", bundleLength%Byte.SIZE==0 ? bundleLength/Byte.SIZE: bundleLength/Byte.SIZE + 1 )); } // There are various ways to stop the Task threads. // It is resembling brake and full stop a car or similar mechanical devices. for (Future<?> f : fl) { f.cancel(true); while (!f.isDone()) ; } Shared.halted = true; exec.shutdown(); System.out.println("Show buffered results."); for (String s: getResults()) { System.out.println(s); } System.out.println("End of main."); } }

We relase jdfr1.0.jar and treetorplus3.jar in January, 2013.

Introduction:
- treetor, a tree/forest rendering tool
- jdfr, Java Dead-lock Free Runtime (the goal, may be too ambitious)

Features:
- the bundle fully supports Java ReentrantLock
- treetor can render a tree graph or forest graph with some dozens of thousand nodes
- so far, the bundle only runs with JDK/JRE 7.
- check the blog sections for more details.

Download:
wget http://www.heteroclinic.net/attached/jdfr1.0.jar wget http://www.heteroclinic.net/attached/treetorplus3.jar

Quick-starts:
Linux
java -cp treetorplus3.jar;jdfr1.0.jar javax.util.concurrent.profilable.test.Test20130120_MultiTier .\
or Windows
java -cp treetorplus3.jar:jdfr1.0.jar javax.util.concurrent.profilable.test.Test20130120_MultiTier ./
It will create ".png"s in the current directory.

Multi-tier
java -cp treetorplus3.jar;jdfr1.0.jar javax.util.concurrent.profilable.test.Test20130120_MultiTier .\

Fast
java -cp treetorplus3.jar;jdfr1.0.jar javax.util.concurrent.profilable.test.Test20130120_Fast .\

Random
java -cp treetorplus3.jar;jdfr1.0.jar javax.util.concurrent.profilable.test.Test20130121_Random .\

Simple dead-lock profiled
java -cp treetorplus3.jar;jdfrbeta01.jar javax.util.concurrent.profilable.test.Test20121210_DEAD_LOCK_VISUAL .\

/* Science and technology promotion license applied. (c) Zhikai Wang/ www.heteroclinic.net 2013 */ /* results: $ g++ -o RecursiveRandomBitFlipPermuationGeneration.exe RecursiveRandomBitFlipPermuationGeneration.cpp $ ./RecursiveRandomBitFlipPermuationGeneration.exe It took 25.849 seconds for size=30. So theoretically for size = 40 (forty bits) will take 25.84 * 1024 seconds, namely ABT 5,000 minutes. My 6G/Q9000/Vista Cygwin laptop can do it. You print the result for small value of variable 'size', e.g., 5, 4 etc. */ #include <iostream> #include <cstdlib> #include <climits> #include <string.h> #include <bitset> #include <time.h> #include <ctime> // ULLONG_MAX should be 2^64-1 = 1.8446744073709551615e+19 // 20! is 2.43290200817664e+18 // 21! is 5.109094217170944e+19 //overflow // So it is not possible to use index permutation, we still need shuffling. // c is the length void printULLinBits (unsigned long long start_pattern) ; void shuffleAnArray (int c, int * myarray) { //srand(3); int array_i=0; for (array_i=0; array_i < c-1 ; array_i++) { int v = rand() % (c -array_i); //std::cout<<"v:"<<v<<" "<<"c-array_i:"<<c -array_i<<" "; //std::cout<<"v:"<<v<<" "; if (v!=0) { int cursor = v+array_i; if (cursor >= c) continue; int tmp = myarray[cursor ]; myarray[cursor ] = myarray[array_i]; myarray[array_i] = tmp; } } //std::cout<<std::endl; } // assert : position >=1 && position <= 64 // I am not sure about the endianness of bit OPs inline void flipOneBitofAULL (unsigned long long * p_start_pattern, int position) { (*p_start_pattern) ^= 1 << (position-1); } // inline void flipOneBitofAULL (unsigned long long * p_start_pattern, int position) { // int spi = position; // //unsigned long long start_pattern = ULLONG_MAX; // unsigned long upper_pattern = 0LL; // unsigned long lower_pattern = 0LL; // //memcpy(&lower_pattern, &start_pattern, sizeof lower_pattern); // //memcpy(&upper_pattern, (char *) &start_pattern + sizeof lower_pattern, sizeof upper_pattern); // memcpy(&lower_pattern, p_start_pattern, sizeof lower_pattern); // memcpy(&upper_pattern, (char *) p_start_pattern + sizeof lower_pattern, sizeof upper_pattern); // if ( spi < 32 ) { // lower_pattern &= ~(1 << spi); // memcpy(p_start_pattern, &lower_pattern, sizeof lower_pattern); // } else { // upper_pattern &= ~(1 << (spi-32)); // memcpy( (char *) p_start_pattern + sizeof lower_pattern,&upper_pattern, sizeof upper_pattern); // } // std::cout<<lower_pattern <<std::endl; // std::cout<<upper_pattern <<std::endl; // std::cout<<*p_start_pattern <<std::endl; // } // assert : totaldepth >= currentdepth > 1s // If you pet something with claw(s), other things' pattern(s) may be changed. void recursiveRandomBitsFlipPermute(unsigned long long * p_start_pattern, int totaldepth, int currentdepth, int * claw, bool printdeepest ) { if ( currentdepth < totaldepth) { //std::cout<<"currentdepth "<<currentdepth<<std::endl; //flip enter recursion //flipOneBitofAULL (p_start_pattern,claw[currentdepth-1]); if (currentdepth > 0 ) { //std::cout<<"\t\t"<< * p_start_pattern<<"\t claw"<<claw[currentdepth-1]<<std::endl; (*p_start_pattern) ^= 1 << (claw[currentdepth-1]-1); //std::cout<<"\t\t"<< * p_start_pattern<<"\t claw"<<claw[currentdepth-1]<<std::endl; } recursiveRandomBitsFlipPermute(p_start_pattern, totaldepth, currentdepth + 1, claw ,printdeepest); //flip back enter recursion //flipOneBitofAULL (p_start_pattern,claw[currentdepth-1]); if (currentdepth > 0 ) { //std::cout<<"\t\t"<< * p_start_pattern<<"\t claw"<<claw[currentdepth-1]<<std::endl; (*p_start_pattern) ^= 1 << (claw[currentdepth-1]-1); //std::cout<<"\t\t"<< * p_start_pattern<<"\t claw"<<claw[currentdepth-1]<<std::endl; } recursiveRandomBitsFlipPermute(p_start_pattern, totaldepth, currentdepth + 1, claw ,printdeepest); //++currentdepth; } if( currentdepth == totaldepth) { // flip print // flip back print // no more recursive call // std::cout<<"currentdepth "<<currentdepth<<std::endl; (*p_start_pattern) ^= 1 << (claw[currentdepth-1]-1); //printULLinBits (*p_start_pattern); if (printdeepest) std::cout<<"\t\t\t"<< * p_start_pattern<<std::endl; (*p_start_pattern) ^= 1 << (claw[currentdepth-1]-1); if (printdeepest) std::cout<<"\t\t\t"<< * p_start_pattern<<std::endl; //printULLinBits (*p_start_pattern); } } void printULLinBits (unsigned long long start_pattern) { //unsigned long long start_pattern = ULLONG_MAX; unsigned long upper_pattern = 0LL; unsigned long lower_pattern = 0LL; memcpy(&lower_pattern, &start_pattern, sizeof lower_pattern); memcpy(&upper_pattern, (char *) &start_pattern + sizeof lower_pattern, sizeof upper_pattern); std::bitset<32> bsup(upper_pattern); std::bitset<32> bslo(lower_pattern); std::cout<<bsup <<bslo <<std::endl; } int main () { srand((unsigned)time(NULL)); int size = 20; int * array = new int[size]; int i = 0; for (i = 0; i< size; i++ ) { array[i] = i+1; } shuffleAnArray (size, array); //for (i = 0; i< size; i++ ) { // std::cout<<array[i]<<std::endl; //} // int * tmp_arr = new int[size]; // std::cout<<"(sizeof (int)) * size :"<< ((sizeof (int)) * size)<<std::endl; // for (i = 0; i< size; i++ ) { // tmp_arr[i]=array[i]; // } // for (i = 0; i< 1024; i++) { // memcpy(tmp_arr, array, ((sizeof (int)) * size)); // // std::cout<<rand() % 3<<std::endl; // shuffleAnArray (size, tmp_arr); // int tmp_i = i; // for (i = 0; i< size; i++ ) { // std::cout<<tmp_arr[i]<<" "; // } // std::cout<<std::endl; // i = tmp_i; // } // unsigned long upper_pattern = 1024-1L; // //upper_pattern ^= ~(1 << 5); // unsigned int x = 5; // upper_pattern ^= 1 << x; // std::cout<<upper_pattern<<std::endl; // //upper_pattern ^= ~(1 << 5); // upper_pattern ^= 1 << x; // std::cout<<upper_pattern<<std::endl; // //!!!! DO NOT DELELET The following is the correct way to toggle ULL bit // //But the least bit is 0 not 1. // //???? hope c++ will deal with the endianness // unsigned long long start_pattern = ULLONG_MAX; // printULLinBits (start_pattern ); // start_pattern ^= 1ULL << 10; // printULLinBits (start_pattern ); // start_pattern ^= 1ULL << 40; // printULLinBits (start_pattern ); // start_pattern ^= 1ULL << 40; // printULLinBits (start_pattern ); // start_pattern ^= 1ULL << 63; // printULLinBits (start_pattern ); //unsigned long long start_pattern = ULLONG_MAX; unsigned long long start_pattern = 0ULL; //recursiveRandomBitsFlipPermute(unsigned long long * p_start_pattern, int totaldepth, int currentdepth, int * claw ) clock_t start; double diff; clock_t endd = std::clock(); start = std::clock(); recursiveRandomBitsFlipPermute(&start_pattern, size, 1, array,false ) ; endd = std::clock(); diff = ( endd - start ) / (double)CLOCKS_PER_SEC; std::cout<<"It took "<<diff <<" seconds for size="<<size<<"." <<std::endl; return 0; }

A pair of sharp eyes may already see through and catch a big hole of Recursive Random Bit Flip Permutation, but to fill the hole would seem to be easier. It took longer time to imagine the bit-flip method. Shorter time (two or three) days finding the hole. Even shorter to imagine a way to fill the hole. As of today, everything is still imagination, Mar 19, 2013. In this episode, I meant to close the depth peeling transparency project and I will open the code. But I forgot to bring the code four years ago with my travel.
We will fill the hole in the coming episode(s).

Computation and Visualization of Invariant Manifold is the topic of Zhikai Wang's master thesis at computer science department of Concordia University, Canada.

The full text in pdf is here, the abstract, and the final presentation.

In this thesis, we start with the basic concepts of dynamical systems. Then we introduce the general types of problems that the well-known software package AUTO solves. AUTO uses a boundary value algorithm with Gaussian collocation and pseudo-arclength continuation. The two features distinguish AUTO from other general ODE solvers for dynamical systems. In order to compute 2D solution manifolds, AUTO uses orbit continuation. With these tools, we study two famous problems, the Lorenz system and the circular restricted Three-Body problem (CR3BP). We brie fly discuss the basic bifurcation and stability analysis of ODE systems. The numerical analysis of the two problems leads to the newest algorithm to compute the 2D stable manifold of the origin of the Lorenz system and the 2D unstable manifold of appropriate periodic orbits of the CR3BP. We utilize Python for the flow control of AUTO. We also implement two visualization packages, QTPlaut and MATPlaut. They make possible the processing of large quantities of AUTO solution data with the OpenGL graphical library, dynamic memory allocation and interpolation methods. We conclude with prospect for future research.

QTPlaut Win32-binary EXE (md5sum result cd03d4117d953f5d4e1d695d3bcc8727) is put online, on Jan 15,2011. For install under Microsoft Windows and only, download the binary/EXE file. If some DLLs are required, please google 'vcredist 2010', download and install. Then execute the binary.

For QT developer: the source code is here source code. A kaopoo/practical in-hand story is -- Visual C++ 2010 express, QT 4.7.1.(configure static, nmake).

We also put the beta version user manual in pdf form here. An AUTO solution we select is the Lorenz Manifold. More are coming. The file 's15.zip' has to be unzipped as 's.15'. According to a filter all files should begin with 's.' something.

A shortcut to play with the 's.15' is: click 'add a solution', click 'scene tool', click 'Construct a manifold'. The Lorenz manifold is computed by AUTO .

Sinpixa is the project code name for Equation

Sinpixa01.pdf

Java executable jar and dependencies:
FriendsTorusDemo4.0binary.zip
md5sum: FriendsTorusDemo4.0binary.zip
b9c520543c309b0d02b34a5ab3dca743

Friends Torus Social Network in a new Dimension is a new brain tease and project adventure of Zhikai Wang/www.heteroclinic.net.
This Demo 3.0 program so far is tested on some Windows and Linux machines. The hardware requirement is quite minimal.
Demo 3.0 New Features:
- integrated with hybrid http/https server
- automatic passing token from browser to desktop application
Issues remains:
- a lot
- Chrome browser OK, IE not OK
- If the browser asks about SSL certificate questions, click "Proceed".
- You have to wait a while, while the application is downloading the pictures of your friends.
After the Web browser pops up a new window showing some Facebook ops accomplished, you can switch to the Java desktop Application see something like Demo 1.0 screenshot.

Java executable jar and dependencies:
FriendsTorusDemo3.0binary.zip
md5sum: FriendsTorusDemo3.0binary.zip
733b8a59d7d84419e0fd3184f9065f50

How it works

Get the source and built jar:

Foakenbeta1.0.zip
md5sum: 5af2b95052d71aa885ede1927069fb9e