manolas
/
vcglib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Optimizing realtime vis.

This commit is contained in:
Federico Ponchio 2004-12-15 08:46:16 +00:00
parent 7fb2c4b831
commit e8c748d159
9 changed files with 421 additions and 238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

213
apps/nexus/nexusmt.cpp
View File

@ -57,14 +57,17 @@ float FrustumMetric::GetError(unsigned int cell) {
if(dist < 0) return 1e20f;
float error = entry.error/frustum.Resolution(dist);
if(frustum.IsOutside(sphere.Center(), sphere.Radius()))
error /= 256;
error /= 32;
return error;
}
bool NexusMt::Expand(TNode &node) {
bool NexusMt::Expand(TNode &tnode) {
//expand if node error > target error
if(extraction_used >= extraction_max) return false;
return node.error > target_error;
if(extraction_used >= extraction_max) return false;
if(draw_used >= draw_max) return false;
if(disk_used >= disk_max) return false;
return tnode.error > target_error;
}
void NexusMt::NodeVisited(Node *node) {
@ -75,8 +78,15 @@ void NexusMt::NodeVisited(Node *node) {
assert(!(node->out[i]->visited));
Frag &frag = node->frags[i];
for(unsigned int k = 0; k < frag.size(); k++) {
PServer::Entry &entry = patches.entries[frag[k]];
extraction_used += entry.ram_size;
unsigned int patch = frag[k];
PServer::Entry &entry = patches.entries[patch];
unsigned int ram_size = entry.ram_size;
extraction_used += ram_size;
PatchInfo &info = index[patch];
if(!frustum.IsOutside(info.sphere.Center(), info.sphere.Radius()))
draw_used += ram_size;
if(!patches.entries[patch].patch)
disk_used += ram_size;
}
}
@ -88,8 +98,14 @@ void NexusMt::NodeVisited(Node *node) {
if((*from)->out[i] == node) {
vector<unsigned int> &frag = frags[i];
for(unsigned int k = 0; k < frag.size(); k++) {
PServer::Entry &entry = patches.entries[frag[k]];
extraction_used -= entry.ram_size;
unsigned int patch = frag[k];
PServer::Entry &entry = patches.entries[patch];
extraction_used -= entry.ram_size;
PatchInfo &info = index[patch];
if(!frustum.IsOutside(info.sphere.Center(), info.sphere.Radius()))
draw_used -= entry.ram_size;
if(!patches.entries[patch].patch)
disk_used -= entry.ram_size;
}
}
}
@ -101,7 +117,10 @@ NexusMt::NexusMt(): vbo_mode(VBO_AUTO),
metric = new FrustumMetric();
metric->index = &index;
target_error = 4.0f;
extraction_max = 640000000;
extraction_max = 64000000000;
draw_max = 12000; //1M triangles (ZSN)
disk_max = 300;
}
NexusMt::~NexusMt() {
@ -180,7 +199,7 @@ bool NexusMt::Load(const string &filename) {
SetPrefetchSize(patches.ram_max/2);
cerr << "Start!\n";
prefetch.start();
cerr << "Started\n";
return true;
}
@ -199,6 +218,8 @@ bool NexusMt::InitGL(Vbo mode, unsigned int vbosize) {
patches.vbo_max = vbosize / chunk_size;
if(vbo_mode == VBO_OFF)
patches.vbo_max = 0;
prefetch.start();
return true;
}
@ -212,13 +233,23 @@ void NexusMt::Render() {
}
void NexusMt::Draw(vector<unsigned int> &cells) {
prefetch.init(this, cells, visited);
tri_total = 0;
tri_rendered = 0;
Frustumf frustum;
frustum.GetView();
vector<unsigned int> draw;
for(unsigned int i = 0; i < cells.size(); i++) {
PatchInfo &entry = index[cells[i]];
tri_total += entry.nface;
if(!frustum.IsOutside(entry.sphere.Center(), entry.sphere.Radius())) {
draw.push_back(cells[i]);
tri_rendered += entry.nface;
}
}
prefetch.init(this, draw, visited);
glEnableClientState(GL_VERTEX_ARRAY);
if(use_colors)
glEnableClientState(GL_COLOR_ARRAY);
@ -226,37 +257,36 @@ void NexusMt::Draw(vector<unsigned int> &cells) {
glEnableClientState(GL_NORMAL_ARRAY);
//TODO textures and data.
unsigned int count = cells.size();
while(count) {
// cerr << "Getting message: " << count << endl;
pt::message *msg = patches.queue.getmessage();
QueuePServer::Data *data = (QueuePServer::Data *)(msg->param);
if(msg->id == QueuePServer::FLUSH) {
// cerr << "Flush...\n";
if(data->vbo_element) {
glDeleteBuffersARB(1, &(data->vbo_element));
glDeleteBuffersARB(1, &(data->vbo_array));
unsigned int count = draw.size();
while(count > 0 || prefetch.draw.get_count()) {
if(todraw.size()) {
QueuePServer::Data *data = todraw.back();
todraw.pop_back();
Draw((unsigned int)(data->patch), *data);
} else {
// cerr << "Getting message: " << count << endl;
pt::message *msg = prefetch.draw.getmessage();
QueuePServer::Data *data = (QueuePServer::Data *)(msg->param);
if(msg->id == QueuePServer::FLUSH) {
if(data->vbo_element) {
glDeleteBuffersARB(1, &(data->vbo_element));
glDeleteBuffersARB(1, &(data->vbo_array));
}
delete data;
delete msg;
continue;
}
delete data;
if(msg->id != QueuePServer::DRAW) {
cerr << "Unknown message!\n";
continue;
}
unsigned int cell = msg->result;
Draw(cell, *data);
delete msg;
continue;
}
if(msg->id != QueuePServer::DRAW) {
cerr << "Unknown message!\n";
continue;
}
unsigned int cell = msg->result;
PatchInfo &entry = index[cell];
tri_total += entry.nface;
//frustum culling
if(!frustum.IsOutside(entry.sphere.Center(), entry.sphere.Radius())) {
tri_rendered += entry.nface;
Draw(cell, *data);
}
delete msg;
count--;
}
glDisableClientState(GL_VERTEX_ARRAY);
@ -455,7 +485,7 @@ void NexusMt::LoadHistory() {
Node &oldnode = nodes[floor_node];
oldnode.frags.push_back(fr);
if(node.error < max_err)
node.error = max_err;
node.error = max_err;
//Update in and out of the nodes.
node.in.push_back(&oldnode);
@ -502,18 +532,24 @@ void NexusMt::ClearHistory() {
void NexusMt::Extract(std::vector<unsigned int> &selected) {
extraction_used = 0;
draw_used = 0;
disk_used = 0;
visited.clear();
float bestcost = -1;
int best = -1;
float cost = 0;
std::vector<Node>::iterator n;
for(n = nodes.begin(); n != nodes.end(); n++) {
(*n).visited = false;
// (*n).pushed = false;
}
for(n = nodes.begin(); n != nodes.end(); n++)
(*n).visited = false;
std::vector<TNode> heap;
Node *root = &nodes[0];
VisitNode(root, heap);
sequence.clear();
//vector<Node *> sequence;
while(heap.size()) {
pop_heap(heap.begin(), heap.end());
TNode tnode = heap.back();
@ -524,9 +560,40 @@ void NexusMt::Extract(std::vector<unsigned int> &selected) {
bool expand = Expand(tnode);
if(expand)
VisitNode(node, heap);
if(expand) //{
VisitNode(node, heap);
/* float cost = disk_used * 100;
if(draw_used > draw_max)
cost += 1 * (draw_used - draw_max);
if(tnode.error > target_error)
cost += 1000 * (tnode.error - target_error) * (tnode.error - target_error);
if(best == -1 || cost < bestcost) {
bestcost = cost;
best = sequence.size();
}
} */
}
//cerr << "best: " << best << " tot: " << sequence.size() << endl;
/*for(n = nodes.begin(); n != nodes.end(); n++)
(*n).visited = false;
for(unsigned int i = 0; i < best; i++) {
Node *node = sequence[i];
node->visited = true;
for(unsigned int n = 0; n < node->out.size(); n++) {
Node *outnode = node->out[n];
for(unsigned int k = 0; k < outnode->frags.size(); k++) {
for(unsigned int j = 0; j < outnode->frags[k].size(); j++) {
unsigned int patch = outnode->frags[k][j];
float error = metric->GetError(patch);
visited.push_back(PServer::Item(patch, fabs(error - target_error)));
}
}
}
} */
Select(selected);
}
@ -556,7 +623,7 @@ void NexusMt::Extract(std::vector<unsigned int> &selected) {
}
}
Select(selected);
}*/
} */
void NexusMt::Select(vector<unsigned int> &selected) {
selected.clear();
@ -579,18 +646,38 @@ void NexusMt::Select(vector<unsigned int> &selected) {
}
}
}
/*bool NexusMt::TestCurrent(Node *node) {
if(!visited) return;
for(unsigned int i = 0; i < node->out.size(); i++)
if(!node->out[k].visited) {
node->current = true;
return true;
}
node->current = false;
return false;
} */
void NexusMt::VisitNode(Node *node, vector<TNode> &heap) {
if(node->visited) return;
//TestCurrent(*i);
if(node->visited) return;
node->visited = true;
vector<Node *>::iterator i;
for(i = node->in.begin(); i != node->in.end(); i++)
VisitNode(*i, heap);
for(i = node->in.begin(); i != node->in.end(); i++) {
VisitNode(*i, heap);
}
for(unsigned int k = 0; k < node->out.size(); k++) {
Node *outnode = node->out[k];
float max_error = 0;
float max_error = metric->GetError(outnode);
/* for(unsigned int j = 0; j < node->frags[k].size(); j++) {
unsigned int patch = node->frags[k][j];
PServer::Entry &entry = patches.entries[patch];
if(!entry.patch)
max_error /= 2;
}*/
for(unsigned int j = 0; j < node->frags[k].size(); j++) {
unsigned int patch = node->frags[k][j];
@ -598,13 +685,23 @@ void NexusMt::VisitNode(Node *node, vector<TNode> &heap) {
if(max_error < error) max_error = error;
visited.push_back(PServer::Item(patch, fabs(error - target_error)));
// push_heap(visited.begin(), visited.end());
}
}
heap.push_back(TNode(outnode, max_error));
push_heap(heap.begin(), heap.end());
}
node->visited = true;
sequence.push_back(node);
NodeVisited(node);
}
/*void NexusMt::UnvisitNode(Node *node, vector<TNode> &heap) {
node->current = false;
vector<Node *>::iterator i;
for(i = node->in.begin(); i != node->in.end(); i++)
if(TestCurrent(*i)) {
float error = metric->GetError(*i);
heap.push_back(TNode(*i, error));
push_heap(heap.begin(), heap.end());
}
} */

18
apps/nexus/nexusmt.h
View File

@ -19,7 +19,8 @@ namespace nxs {
std::vector<Node *> out;
std::vector<Frag> frags;
float error;
bool visited;
bool visited;
bool current;
// bool pushed;
};
@ -102,9 +103,15 @@ class NexusMt: public NexusBase {
Metric *metric;
float target_error;
int extraction_max;
int extraction_used;
vcg::Frustumf frustum;
unsigned int extraction_max; //total extraxtion (even culled parts)
unsigned int extraction_used;
unsigned int draw_max; //only visible parts
unsigned int draw_used;
unsigned int disk_max; //max not in ram loadable size
unsigned int disk_used;
Mode mode;
@ -119,7 +126,9 @@ class NexusMt: public NexusBase {
unsigned int tri_rendered;
unsigned int tri_total;
vector<QueuePServer::Data *> todraw;
std::vector<PServer::Item> visited;
std::vector<Node *> sequence;
QueuePServer patches;
BorderServer borders;
@ -160,6 +169,7 @@ class NexusMt: public NexusBase {
void LoadHistory();
void ClearHistory();
void VisitNode(Node *node, std::vector<TNode> &heap);
void UnvisitNode(Node *node, std::vector<TNode> &heap);
void Select(std::vector<unsigned int> &selected);
Patch &LoadPatch(unsigned int p);
};

206
apps/nexus/nexusview.cpp
View File

@ -24,6 +24,9 @@
History
$Log: not supported by cvs2svn $
Revision 1.24 2004/12/13 00:44:48 ponchio
Lotsa changes...
Revision 1.23 2004/12/01 18:46:21 ponchio
Microchanges.
@ -209,14 +212,17 @@ int main(int argc, char *argv[]) {
" q: quit\n"
" s: screen error extraction\n"
" g: geometry error extraction\n"
" p: draw points\n"
" t: show statistics\n"
" r: toggle realtime mode (TODO)\n"
" b: increase memory buffer\n"
" B: decrease memory buffer\n"
" d: debug mode (show patches colored)\n"
" f: flas shading mode\n"
" m: smooth mode\n"
" p: draw points\n"
" c: show colors\n"
" n: show normals\n"
" u: rotate model\n"
@ -233,11 +239,9 @@ int main(int argc, char *argv[]) {
bool extract = true;
NexusMt::MetricKind metric;
NexusMt::Mode mode = NexusMt::SMOOTH;
unsigned int ram_size = 640000;
NexusMt::Mode mode = NexusMt::SMOOTH;
nexus.SetError(error);
nexus.SetExtractionSize(ram_size);
nexus.SetError(error);
nexus.SetMetric(NexusMt::FRUSTUM);
if(!nexus.InitGL()) {
cerr << "Could not init glew.\n";
@ -256,100 +260,99 @@ int main(int argc, char *argv[]) {
bool redraw = false;
float fps = 0;
float tframe = 0;
bool keepdrawing = true;
while( !quit ) {
bool first = true;
SDL_WaitEvent(&event);
while( first || SDL_PollEvent( &event ) ){
first = false;
switch( event.type ) {
case SDL_QUIT: quit = 1; break;
case SDL_KEYDOWN:
switch(event.key.keysym.sym) {
case SDLK_RCTRL:
case SDLK_LCTRL:
track.ButtonDown(Trackball::KEY_CTRL); break;
case SDLK_q: exit(0); break;
case SDLK_b: show_borders = !show_borders; break;
case SDLK_e: extract = !extract; break;
case SDLK_c: show_colors = !show_colors; break;
case SDLK_n: show_normals = !show_normals; break;
// case SDLK_9: nexus.patches->ram_size *= 0.8f; break;
// case SDLK_0: nexus.patches->ram_size *= 1.2f; break;
case SDLK_LEFT:
ram_size *= 0.7;
nexus.SetExtractionSize(ram_size);
cerr << "Max extraction ram size: " << ram_size << endl; break;
case SDLK_RIGHT:
ram_size *= 1.5;
nexus.SetExtractionSize(ram_size);
cerr << "Max extraction ram size: " << ram_size << endl; break;
while( !quit ) {
unsigned int anything = SDL_PollEvent(&event);
if(!anything && !keepdrawing) {
SDL_WaitEvent(&event);
anything = true;
}
if(anything) {
switch( event.type ) {
case SDL_QUIT: quit = 1; break;
case SDL_KEYDOWN:
switch(event.key.keysym.sym) {
case SDLK_RCTRL:
case SDLK_LCTRL: track.ButtonDown(Trackball::KEY_CTRL); break;
case SDLK_q: exit(0); break;
case SDLK_k: keepdrawing = !keepdrawing; break;
case SDLK_e: extract = !extract; break;
case SDLK_c: show_colors = !show_colors; break;
case SDLK_n: show_normals = !show_normals; break;
case SDLK_LEFT: nexus.extraction_max *= 0.7; break;
case SDLK_RIGHT: nexus.extraction_max *= 1.5; break;
case SDLK_UP: nexus.draw_max *= 1.5; break;
case SDLK_DOWN: nexus.draw_max *= 0.7; break;
case SDLK_PAGEUP: nexus.disk_max *= 1.5; break;
case SDLK_PAGEDOWN: nexus.disk_max *= 0.7; break;
case SDLK_s: metric = NexusMt::FRUSTUM; break;
case SDLK_p: mode = NexusMt::POINTS; nexus.SetMode(mode); break;
case SDLK_d: mode = NexusMt::PATCHES; nexus.SetMode(mode); break;
case SDLK_f: mode = NexusMt::FLAT; nexus.SetMode(mode); break;
case SDLK_m: mode = NexusMt::SMOOTH; nexus.SetMode(mode); break;
case SDLK_s: metric = NexusMt::FRUSTUM; break;
case SDLK_p: mode = NexusMt::POINTS; nexus.SetMode(mode); break;
case SDLK_d: mode = NexusMt::PATCHES; nexus.SetMode(mode); break;
case SDLK_f: mode = NexusMt::FLAT; nexus.SetMode(mode); break;
case SDLK_m: mode = NexusMt::SMOOTH; nexus.SetMode(mode); break;
case SDLK_r:
case SDLK_SPACE: rotate = !rotate; break;
case SDLK_r:
case SDLK_SPACE: rotate = !rotate; break;
case SDLK_MINUS:
error *= 0.9f;
nexus.SetError(error);
cerr << "Error: " << error << endl; break;
case SDLK_MINUS:
error *= 0.9f;
nexus.SetError(error);
cerr << "Error: " << error << endl; break;
case SDLK_EQUALS:
case SDLK_PLUS:
error *= 1.1f;
nexus.SetError(error);
cerr << "Error: " << error << endl; break;
}
break;
case SDL_KEYUP:
switch(event.key.keysym.sym) {
case SDLK_RCTRL:
case SDLK_LCTRL:
track.ButtonUp(Trackball::KEY_CTRL); break;
}
break;
case SDL_MOUSEBUTTONDOWN:
x = event.button.x;
y = height - event.button.y;
#ifdef SDL_BUTTON_WHEELUP
if(event.button.button == SDL_BUTTON_WHEELUP)
track.MouseWheel(1);
else if(event.button.button == SDL_BUTTON_WHEELDOWN)
track.MouseWheel(-1);
else
#endif
if(event.button.button == SDL_BUTTON_LEFT)
track.MouseDown(x, y, Trackball::BUTTON_LEFT);
else if(event.button.button == SDL_BUTTON_RIGHT)
track.MouseDown(x, y, Trackball::BUTTON_RIGHT);
break;
case SDL_MOUSEBUTTONUP:
x = event.button.x;
y = height - event.button.y;
if(event.button.button == SDL_BUTTON_LEFT)
track.MouseUp(x, y, Trackball::BUTTON_LEFT);
else if(event.button.button == SDL_BUTTON_RIGHT)
track.MouseUp(x, y, Trackball::BUTTON_RIGHT);
break;
case SDL_MOUSEMOTION:
while(SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_MOUSEMOTIONMASK));
x = event.motion.x;
y = height - event.motion.y;
track.MouseMove(x, y);
break;
case SDL_VIDEOEXPOSE:
default: break;
case SDLK_EQUALS:
case SDLK_PLUS:
error *= 1.1f;
nexus.SetError(error);
cerr << "Error: " << error << endl; break;
}
break;
case SDL_KEYUP:
switch(event.key.keysym.sym) {
case SDLK_RCTRL:
case SDLK_LCTRL:
track.ButtonUp(Trackball::KEY_CTRL); break;
}
break;
case SDL_MOUSEBUTTONDOWN:
x = event.button.x;
y = height - event.button.y;
#ifdef SDL_BUTTON_WHEELUP
if(event.button.button == SDL_BUTTON_WHEELUP)
track.MouseWheel(1);
else if(event.button.button == SDL_BUTTON_WHEELDOWN)
track.MouseWheel(-1);
else
#endif
if(event.button.button == SDL_BUTTON_LEFT)
track.MouseDown(x, y, Trackball::BUTTON_LEFT);
else if(event.button.button == SDL_BUTTON_RIGHT)
track.MouseDown(x, y, Trackball::BUTTON_RIGHT);
break;
case SDL_MOUSEBUTTONUP:
x = event.button.x;
y = height - event.button.y;
if(event.button.button == SDL_BUTTON_LEFT)
track.MouseUp(x, y, Trackball::BUTTON_LEFT);
else if(event.button.button == SDL_BUTTON_RIGHT)
track.MouseUp(x, y, Trackball::BUTTON_RIGHT);
break;
case SDL_MOUSEMOTION:
while(SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_MOUSEMOTIONMASK));
x = event.motion.x;
y = height - event.motion.y;
track.MouseMove(x, y);
break;
case SDL_VIDEOEXPOSE:
default: break;
}
}
redraw = true;
}
if(!redraw) continue;
//if(!redraw && !keepdrawing) continue;
redraw = false;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
@ -363,9 +366,11 @@ int main(int argc, char *argv[]) {
if(rotate) {
alpha++;
if(alpha > 360) alpha = 0;
SDL_Event redraw;
redraw.type = SDL_VIDEOEXPOSE;
SDL_PushEvent(&redraw);
if(!keepdrawing) {
SDL_Event redraw;
redraw.type = SDL_VIDEOEXPOSE;
SDL_PushEvent(&redraw);
}
}
@ -440,8 +445,8 @@ int main(int argc, char *argv[]) {
gl_print(0.03, 0.12, buffer);*/
sprintf(buffer, "Extr size: %.3fMb(max) %.3fMb(cur)",
nexus.extraction_max * nexus.chunk_size/(float)(1<<20),
nexus.extraction_used * nexus.chunk_size/(float)(1<<20));
nexus.patches.ram_max * nexus.chunk_size/(float)(1<<20),
nexus.patches.ram_used * nexus.chunk_size/(float)(1<<20));
gl_print(0.03, 0.09, buffer);
sprintf(buffer, "Vbo size : %.3fMb(max) %.3fMb(cur)",
@ -455,12 +460,7 @@ int main(int argc, char *argv[]) {
nexus.tri_rendered/(float)(1<<10),
tframe, 1/tframe);
gl_print(0.03, 0.03, buffer);
/* cerr << "Ram flushed: " << nexus.patches.ram_flushed << endl;
cerr << "Ram readed: " << nexus.patches.ram_readed << endl;*/
nexus.patches.ram_flushed = 0;
nexus.patches.ram_readed = 0;
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glPopMatrix();

122
apps/nexus/prefetch.cpp
View File

@ -1,3 +1,5 @@
#include <set>
#include "prefetch.h"
#include "nexusmt.h"
@ -13,18 +15,30 @@ void Prefetch::init(NexusMt *m, std::vector<unsigned int> &selected,
safety.lock();
mt = m;
missing.clear();
mt->todraw.clear();
unsigned int notloaded = 0;
std::map<unsigned int, float> tmp;
set<unsigned int> tmp;
//std::map<unsigned int, float> tmp;
vector<QueuePServer::Data> flush;
for(unsigned int i = 0; i < selected.size(); i++) {
unsigned int patch = selected[i];
tmp[patch] = 0.0f;
if(!mt->patches.IsLoaded(patch))
notloaded++;
// if(mt->patches.IsLoaded(patch))
// mt->todraw.push_back(make_pair(patch, (Patch *)NULL));
// else
missing.push_back(PServer::Item(patch, 0.0f));
tmp.insert(patch);
//tmp[patch] = 0.0f;
if(!mt->patches.entries[patch].patch) {
//cerr << "miss: " << patch << endl;
load.post(patch);
notloaded++;
} else {
PatchInfo &info = mt->index[patch];
QueuePServer::Data &data = mt->patches.Lookup(patch, info.nvert, info.nface, 0.0f, flush);
if(flush.size() != 0) {
cerr << "Flushing!\n";
exit(0);
}
mt->todraw.push_back(&data);
}
//missing.push_back(PServer::Item(patch, 0.0f));
}
if(notloaded)
cerr << "Patches to load: " << notloaded << endl;
@ -32,52 +46,84 @@ void Prefetch::init(NexusMt *m, std::vector<unsigned int> &selected,
for(unsigned int i = 0; i < visited.size(); i++) {
PServer::Item &item = visited[i];
if(tmp.count(item.patch)) continue;
if(mt->patches.IsLoaded(item.patch))
tmp[item.patch] = item.priority;
missing.push_back(item);
// if(mt->patches.entries[item.patch].patch)
// tmp[item.patch] = item.priority;
if(item.priority != 0.0f)
missing.push_back(item);
}
QueuePServer &ps = mt->patches;
for(unsigned int i = 0; i < ps.heap.size(); i++) {
PServer::Item &item = ps.heap[i];
if(tmp.count(item.patch))
item.priority = 0;
else {
if(item.priority == 0)
item.priority = 1;
item.priority *= 1.1;
}
/*if(tmp.count(item.patch))
item.priority = tmp[item.patch];
else
item.priority = 1e40;
item.priority = 1e30;*/
}
make_heap(ps.heap.begin(), ps.heap.end());
sort(missing.begin(), missing.end()); //CRITICAL reverse pero'!
reverse(missing.begin(), missing.end());
reverse(missing.begin(), missing.end());
load.post(0xffffffff);
safety.unlock();
}
void Prefetch::execute() {
while(1) {
if(get_signaled()) return;
void Prefetch::execute() {
while(1) {
safety.lock();
if(missing.size() == 0) {
safety.unlock();
break;
}
PServer::Item item = missing.back();
missing.pop_back();
if(item.priority > 0 &&
mt->patches.ram_used > mt->patches.ram_max &&
item.priority >= mt->patches.MaxPriority()) {
safety.unlock();
break;
}
PatchInfo &info = mt->index[item.patch];
if(get_signaled()) return;
vector<QueuePServer::Data> flush;
// cerr << "prefetching: " << item.patch << endl;
mt->patches.Lookup(item.patch, info.nvert, info.nface, item.priority);
if(load.get_count() || missing.size() == 0) {
pt::message *msg = load.getmessage();
if(msg->id != 0xffffffff) {
safety.lock();
PatchInfo &info = mt->index[msg->id];
safety.unlock();
}
relax(5);
}
//posting draw message
QueuePServer::Data &data = mt->patches.Lookup(msg->id, info.nvert, info.nface, 0.0f, flush);
pt::message *msg = new pt::message(QueuePServer::DRAW, (unsigned int)&data);
msg->result = msg->id;
draw.post(msg);
//p;osting flush messages
for(unsigned int i = 0; i < flush.size(); i++) {
QueuePServer::Data *data = new QueuePServer::Data;
*data = flush[i];
draw.post(QueuePServer::FLUSH, (unsigned int)data);
}
safety.unlock();
}
delete msg;
} else {
safety.lock();
if(missing.size() != 0) {
PServer::Item item = missing.back();
missing.pop_back();
if(item.priority > mt->patches.MaxPriority()) {
missing.clear();
} else {
PatchInfo &info = mt->index[item.patch];
//cerr << "prefetching: " << item.patch << endl;
mt->patches.Lookup(item.patch, info.nvert, info.nface, item.priority, flush);
for(unsigned int i = 0; i < flush.size(); i++) {
QueuePServer::Data *data = new QueuePServer::Data;
*data = flush[i];
draw.post(QueuePServer::FLUSH, (unsigned int)data);
}
}
}
safety.unlock();
}
}
}

9
apps/nexus/prefetch.h
View File

@ -17,14 +17,15 @@ class Prefetch: public pt::thread{
public:
pt::mutex safety;
unsigned int ram_max;
unsigned int ram_used;
//unsigned int ram_max;
//unsigned int ram_used;
NexusMt *mt;
std::vector<PServer::Item> missing;
pt::jobqueue draw;
pt::jobqueue load;
Prefetch(): thread(false) {}
Prefetch(): thread(false), draw(20000), load(64000) {}
~Prefetch() {
waitfor();
}

24
apps/nexus/pserver.cpp
View File

@ -15,9 +15,6 @@ bool PServer::Create(const std::string &filename,
ram_max = rsize/chunk_size + 1;
ram_used = 0;
ram_readed = 0;
ram_flushed = 0;
return MFile::Create(filename);
}
@ -31,9 +28,6 @@ bool PServer::Load(const std::string &filename, Signature sig,
ram_max = rsize/chunk_size + 1;
ram_used = 0;
ram_readed = 0;
ram_flushed = 0;
return MFile::Load(filename, readonly);
}
@ -51,6 +45,7 @@ bool PServer::ReadEntries(FILE *fp) {
fread(&(entries[i].patch_start), 1, sizeof(unsigned int), fp);
fread(&(entries[i].ram_size), 1, sizeof(unsigned short), fp);
fread(&(entries[i].disk_size), 1, sizeof(unsigned short), fp);
entries[i].patch = NULL;
}
return true;
}
@ -81,6 +76,7 @@ Patch *PServer::LoadPatch(unsigned int idx,
assert(idx < entries.size());
Entry &entry = entries[idx];
if(entry.patch) return entry.patch;
char *ram = new char[entry.ram_size * chunk_size];
#ifdef CONTROLS
@ -108,15 +104,17 @@ Patch *PServer::LoadPatch(unsigned int idx,
delete []disk;
}
}
ram_used += entry.ram_size;
ram_readed += entry.ram_size;
ram_used += entry.ram_size;
entry.patch = patch;
return patch;
}
void PServer::FlushPatch(unsigned int id, Patch *patch) {
//TODO move this into an assert!!!!
if(!patch) return;
Entry &entry = entries[id];
assert(entry.patch == patch);
entry.patch = NULL;
if(!readonly) { //write back patch
if((signature & NXS_COMPRESSED)) {
@ -147,10 +145,8 @@ void PServer::FlushPatch(unsigned int id, Patch *patch) {
}
delete [](patch->start);
delete patch;
ram_used -= entry.ram_size;
ram_flushed += entry.ram_size;
delete patch;
ram_used -= entry.ram_size;
}
void PServer::MaxRamBuffer(unsigned int r_buffer) {

12
apps/nexus/pserver.h
View File

@ -16,6 +16,7 @@ class PServer: public MFile {
unsigned int patch_start; //granularita' Chunk
unsigned short ram_size; //in chunks
unsigned short disk_size; // in chunks (used when compressed)
Patch *patch;
};
/* struct Data {
@ -42,17 +43,8 @@ class PServer: public MFile {
unsigned int ram_max;
unsigned int ram_used;
//statistics:
unsigned int ram_readed;
unsigned int ram_flushed;
//pt::rwlock ramlock; //read only thread safety...
//pt::rwlock disklock; //read only thread safety...
std::vector<Entry> entries;
std::vector<Entry> entries;
PServer(): chunk_size(1024),
ram_max(128000000),

42
apps/nexus/queuepserver.cpp
View File

@ -7,6 +7,42 @@ using namespace nxs;
using namespace pt;
QueuePServer::Data &QueuePServer::Lookup(unsigned int patch,
unsigned short nv, unsigned short nf,
float priority,
vector<QueuePServer::Data> &flush) {
flush.clear();
if(index.count(patch)) {
return index[patch];
} else {
while(ram_used > ram_max) {
if(MaxPriority() == 0) break;
pop_heap(heap.begin(), heap.end());
Item item = heap.back();
heap.pop_back();
assert(item.priority != 0);
Data &data = index[item.patch];
flush.push_back(data);
FlushPatch(item.patch, data.patch);
index.erase(item.patch);
}
Item item(patch, priority);
heap.push_back(item);
push_heap(heap.begin(), heap.end());
Data &data = index[patch];
// cerr << "Loading: " << patch << endl;
data.patch = LoadPatch(patch, nv, nf);
/*if(priority == 0) {
message *msg = new message(DRAW, (unsigned int)&data);
msg->result = patch;
queue.post(msg);
} */
return data;
}
}
/*
QueuePServer::Data &QueuePServer::Lookup(unsigned int patch,
unsigned short nv, unsigned short nf,
float priority) {
@ -48,8 +84,8 @@ QueuePServer::Data &QueuePServer::Lookup(unsigned int patch,
return data;
}
}
QueuePServer::Data &QueuePServer::Lookup(unsigned int patch,
*/
/*QueuePServer::Data &QueuePServer::Lookup(unsigned int patch,
Patch *mem,
float priority) {
if(index.count(patch)) {
@ -75,7 +111,7 @@ QueuePServer::Data &QueuePServer::Lookup(unsigned int patch,
LoadVbo(data);
return data;
}
}
} */
bool QueuePServer::IsLoaded(unsigned int patch) {
return index.count(patch);

13
apps/nexus/queuepserver.h
View File

@ -2,6 +2,7 @@
#define NXS_QUEUE_PSERVER_H
#include <map>
#include <hash_map>
#include <vector>
#include <algorithm>
@ -29,11 +30,15 @@ class QueuePServer: public PServer {
std::map<unsigned int, Data> index;
std::vector<Item> heap;
Data &Lookup(unsigned int patch, unsigned short nv, unsigned short nf,
float priority = 0.0f);
Data &Lookup(unsigned int patch, Patch *mem, float priority = 0.0f);
QueuePServer(): queue(64000) {}
//Data &Lookup(unsigned int patch, unsigned short nv, unsigned short nf,
// float priority = 0.0f);
//return flushing too.
Data &Lookup(unsigned int patch, unsigned short nv, unsigned short nf, float priority,
std::vector<QueuePServer::Data> &data);
bool IsLoaded(unsigned int patch);
float MaxPriority();