• Create Account

zfvesoljc

Member Since 13 Apr 2010
Offline Last Active Jan 24 2015 05:06 PM

Evaluators (polynomial & graph)

07 January 2014 - 09:49 AM

I'm trying to design (and hopefully implement later on) an evaluator system which would work either with polynomial based data or either with point based graph data ( list of [x,y] pairs from which interpolated values are calculated). So, for quick and dirty fade-in/out one can use simple polynomial data to quickly generate linear/exponential/... curves, while graph data points can be used for complex "animations". Evaluators are used by particle and audio system and based on profiling, they take a healthy chunk of the update time.

I already have a working point based evaluator:

- supports arbitrary number of points (data ptr + count)

- basic logic is that based on input relative x value, I have to find corresponding x-1 and x+1 pairs, and interpolate y between them

- float points are compressed into words to reduce data size and to speed up look-up

- constant / linear / step / bezier

What I don't like about it:

- data layout; even though data for multiple evaluators is packed together, it is still in two places (eval object + data*)

- the "find neighboring  points" is currently a for loop, but as points can be unequally spread out, I don't have any other sane way to find them and since number of points is actually low (4-16) I didn't bother with anything but linear search

- logic & data layout; no sensible way to simd optimize this

Initially I had a static array of points but with a large number of evaluators the data grew fast. The data* + count solved that by a large factor. All in all, this is an ok-ish solution, I'm just wondering if there is a better way to handle it (for simd). Regarding the simd optimization, it seems that optimizing one evaluator is not really practical (or even "possible"). It seems more logical to try to run multiple evaluators at once, but to be honest I'm kinda stuck here...

The new polynomial part would be easy to add, the number of constants (degree) would be low, probably 4 or so, so a float vector would be enough to store data (c0 + c1*x + c2*xx + c3*xxx). The data would be used exclusively (its either polynomial or point list).  So, the big question is how to combine/structure both parts of data and how to make the logic simd-able?

tomcat server (or like) on top of webserver

26 October 2013 - 01:44 AM

I'm working an application, let's call it a tool server which will accompany the target applications. The tool server is written in c/c++ and its embedding mongoose web server to allow http/websocket connections. To the target application it's connected via customized network library. The basic logic works: web server hosts a web page, which is using JS and websocket and the communication flow targetapp <-> toolserver <-> webpage is working as intended. This allows us to create "simple" web apps for stats tracking, logging and some data editing. But to do some more "serious" apps we need java applets. To run them we need a proper java server like tomcat.

I'm doing some research on how to combine these two things. I read about mod_jk which is a link between tomcat and apache web server, but since I'm kinda new in these waters, I'm looking for some advice.

1) What would be the "smoothest" way to integrate tomcat server into existing setup? I'd prefer to have a copy only "installation", so when toolserver is started the tomcat should also start, and vice versa on stopping. Just install run/stop service?

2) Biggest issue is how to link web server with tomcat. I presume the webserver would still be entry point? How to handle websocket communication from tomcat webpage to web server and then to tool server?

__FILE/LINE__ macros in copy constructors/operators

08 July 2013 - 04:14 AM

How would one attach __LINE__/__FILE__ macros to copy constructors and assignment operators?

09 March 2012 - 09:02 AM

I'd like to pass some values as vertex shader constants. Since I don't need whole float precision (nor do I have space), I'm wondering what would be best way to pack/compress multiple unsigned 8/16bit integer values into one float constant. Target range in shader is 0.0 - 1.0, basically uv coordinates.

forgot to mention, it's shader version 3

required bit count at compile time

28 February 2012 - 09:05 AM

I'm saving enum values to bit stream, and I would like to use only such number of bits as really required.

```enum EMessage {
mOne = 0,
mTwo,
mThree,
...
mTen,
//
mLast,	 // value 10
};
```

In the above example, the last entry has value of 10, meaning I need at least 4 bits to write it (assuming only positive values). I can calculate this value in runtime via a function, but it would a bit nicer to have this value at compile time so I could do this:

```enum EMessage {
mOne = 0,
mTwo,
mThree,
...
mTen,
//
mLast,	 // value 10
cbcMessage = Func( mLast ),
};
```

where cbcMessage would be "constant" bit count value (in this case 4).

Any ideas?

PARTNERS