Are there any performance differences between all ReactiveX implementations ? Is there a better ecosystem than an other for reactive programming ?
One is not "better" than the other:
RxJava, it its version 3, is based on Java 8 (before it was limited to Java 6 API due to how Android was lagging behind in its runtime support)
So if your ecosystem is Java or Android-base, you should consider RxJava
RxGo is based on Go: its philosophy is to implement the ReactiveX concepts and leverage the main Go primitives (channels, goroutines, etc.) so that the integration between the two worlds is as smooth as possible.
If your program is in Go (like those programs), you can use this library.
For example: ganeshrvel/one-archiver: All-in-one archiver package for Go.
Each one will have their benchmark challenges:
RxJava: 3.x: parallel performs poorly with 10+ parallelism
RxGo: limited benchmark scenario (I have only found one).
Related
It's common to use the runtime API in function calls when programming with CUDA. Different sources insist in the fact that the performance of both APIs is nearly the same, and it's better to focus in memory use and thread organization to improve the performance. So what would be the real difference between the two APIs ?
Quoting from the CUDA documentation: https://docs.nvidia.com/cuda/cuda-driver-api/driver-vs-runtime-api.html#driver-vs-runtime-api
Difference between the driver and runtime APIs
The driver and runtime APIs are very similar and can for the most part be used
interchangeably. However, there are some key differences worth noting
between the two.
Complexity vs. control
The runtime API eases device code management by
providing implicit initialization, context management, and module
management. This leads to simpler code, but it also lacks the level of
control that the driver API has.
How these to c++ web service framworks compare in performance namely staff-wsf and witty?
I did not perform bench marking, But can get idea from following
Although implemented in C++, Wt’s main focus or novelty is not its
performance, but its focus on developing maintainable applications and
its extensive library of built-in widgets. But because it is popular
and widely used in embedded systems, you will find that performance
and foot-print has been optimized too, by virtue of a no-nonsense API,
thoughtful architecture, and C++ …
given in webtoolkit tutorial
I'm experimenting (with some friends) with JVM languages, such as Clojure and Scala. We recently found a functional solution to an algorithm that performed 30 times faster in Scala than in Java. With these functional languages, has anyone used a bytecode profiling tool to see what these functions become in JVM bytecode? What is the best tool to use for this purpose?
For that matter, as I'm just starting to look at bytecode instrumentation and profiling products, which tool is the best to use? I see recommendations on Stackoverflow, but I'm not sure if they are specifically tuned to the desire to see what machine implementation differences exist between two pieces of code, or if they are purely for code-coverage purposes, which is not my interest.
From the tool perspective, JVM languages don't pose any different problem to profiling than plain Java bytecode. What you need is to get an understanding of how things work behind the hood of your fancy functional constructs in order to properly read the results of your profiler.
YourKit or visualVM will be then your friends again.
I'm working on diploma project that heavily uses mathematical calculations and should present some results in 3D. For these purposes I decided to use CUDA or OpenCL for parallel computation of mathematical part and, most possibly, OpenGL for presenting result. In addition, project should be able to be deployed on clusters (operated by MS Windows), for these purposes project supervisor recommended MPI.
My question is the following: where it is easier to combine all these components, in MS Visual tudio
Main part is CUDA + OpenCL + OpenGL, it will be the core of the project.
P.S. This question is not to star holy-war betwen Qt and MS Visual studio.
OpenCL is not limited to GPUs, it can be used for parallel programming in clusters as well. Intel for example provides a OpenCL implementation, that is aimed at multicore CPU and clusters.
So my recommendation is to use OpenCL for both GPU computing and clustering. MPI (Message Passing Interface) is mainly a way to communicate between tasks running on separate cluster nodes. It's not so much of a clustering framework by itself.
I am looking for a programming language/platform which is suited for handling around 1 to 2 GB of data, and can run signal processing algorithms fast enough across platforms (including modern mobile platforms). Did someone come across suitable solutions?. Please share your research and experience on cross-platform development.
My current research effort is complicated, owing to
the increased deployment of powerful [mobile] platforms,
the backing of Java through the popularity of Android (currently the #1 tag on stackoverflow)
I had mixed experience with C# and Mono (It is fast, but cross-platform compatibility can take some additional effort).
I am not looking for High performance computing(HPC), but into developing code with a data and computing-intensive background that performs well with as little effort as possible. A case study scenario for this would be Python code which is adapted to the Cython compiler.
I am not looking for UI-centric projects with solutions such as Phonegap and Adobe Air, but I know little about its performance.
Links:
Cross-Platform Development of High Performance Applications
Using Generic Programming
Native Client: A Sandbox for Portable, Untrusted x86 Native Code
You can perhaps start having a look at Droidcluster