int main() {
int n = 10000000;
int *testData = new int[n];
for (int i = 0; i < n; ++i) {
testData[i] = rand() % INT32_MAX;
}
double time1 = testHeap(testData, n, false);
std::cout << "Without heapify :" << time1 << " s " << std::endl;
double time2 = testHeap(testData, n, true);
std::cout << "With heapify :" << time2 << " s " << std::endl;
return 0;
}
ILboolean testDetermineTypeFromContent(TCHAR* fn)
{
testHeap();
ilInit();
testHeap();
ILuint handle = ilGenImage();
testHeap();
ilBindImage(handle);
testHeap();
//printf("Loading " PathCharMod "\n", sourceFN);
FILE* f = _wfopen(fn, L"rb");
bool loaded = false;
ILenum type = IL_TYPE_UNKNOWN;
if (f != NULL) {
fseek(f, 0, SEEK_END);
myDataSize = ftell(f);
if (myDataSize > 0) {
fseek(f, 0, SEEK_SET);
myData = new BYTE[myDataSize];
size_t read = fread(myData, 1, myDataSize, f);
myReadPos = 0;
if (read == myDataSize) {
//loaded = ilLoadL(IL_TYPE_UNKNOWN, lump, read);
ilSetRead(myOpenProc, myCloseProc, myEofProc, myGetcProc, myReadProc, mySeekProc, myTellProc);
type = ilDetermineTypeFuncs();
if (type == IL_TYPE_UNKNOWN) {
printf("testDetermineTypeFromContent: Failed to determine type of " PathCharMod "\n", fn);
++errors;
}
} else {
printf("testDetermineTypeFromContent: Failed to read " PathCharMod "\n", fn);
++errors;
}
delete myData;
}
fclose(f);
} else {
printf("testDetermineTypeFromContent: Failed to open %S\n", fn);
++errors;
}
testHeap();
ilDeleteImage(handle);
if (type == IL_TYPE_UNKNOWN) {
++errors;
return IL_FALSE;
} else
return IL_TRUE;
}
int main(int argc, char *argv[])
{
int size;
int version;
CMEM_BlockAttrs attrs;
if (argc != 2) {
fprintf(stderr, "Usage: %s <Number of bytes to allocate>\n", argv[0]);
exit(EXIT_FAILURE);
}
size = atoi(argv[1]);
/* First initialize the CMEM module */
if (CMEM_init() == -1) {
fprintf(stderr, "Failed to initialize CMEM\n");
exit(EXIT_FAILURE);
}
printf("CMEM initialized.\n");
version = CMEM_getVersion();
if (version == -1) {
fprintf(stderr, "Failed to retrieve CMEM version\n");
}
printf("CMEM version = 0x%x\n", version);
if (CMEM_getBlockAttrs(0, &attrs) == -1) {
fprintf(stderr, "Failed to retrieve CMEM memory block 0 bounds\n");
}
printf("CMEM memory block 0: phys start = 0x%lx, size = 0x%x\n",
attrs.phys_base, attrs.size);
if (CMEM_getBlockAttrs(1, &attrs) == -1) {
fprintf(stderr, "Failed to retrieve CMEM memory block 1 bounds\n");
}
printf("CMEM memory block 1: phys start = 0x%lx, size = 0x%x\n",
attrs.phys_base, attrs.size);
testHeap(size, 0);
testHeap(size, 1);
testCache(size, 0);
testCache(size, 1);
if (CMEM_exit() < 0) {
fprintf(stderr, "Failed to finalize the CMEM module\n");
}
exit(EXIT_SUCCESS);
}
void test_ilLoad(wchar_t* sourceFN, wchar_t* targetFN)
{
testHeap();
ilInit();
testHeap();
ILuint handle = ilGenImage();
testHeap();
ilBindImage(handle);
testHeap();
//printf("Loading " PathCharMod "\n", sourceFN);
ilResetRead();
ILenum sourceType = ilDetermineType(sourceFN);
if (!ilLoad(sourceType, sourceFN)) {
printf("test_ilLoad: Failed to load %S\n", sourceFN);
++errors;
return;
}
testHeap();
//ilConvertImage(IL_BGR, IL_UNSIGNED_BYTE);
//ilConvertImage(IL_LUMINANCE, IL_UNSIGNED_BYTE);
//iluScale(150, 150, 1);
testHeap();
DeleteFile(targetFN);
//printf("Saving " PathCharMod "\n", targetFN);
if (!ilSaveImage(targetFN)) {
printf("test_ilLoad: Failed to save " PathCharMod "\n", targetFN);
++errors;
}
testHeap();
ilDeleteImage(handle);
}
void test_ilLoadFuncs(wchar_t* sourceFN, wchar_t* targetFN)
{
testHeap();
ilInit();
testHeap();
ILuint handle = ilGenImage();
testHeap();
ilBindImage(handle);
testHeap();
//printf("Loading " PathCharMod "\n", sourceFN);
FILE* f = _wfopen(sourceFN, L"rb");
bool loaded = false;
if (f != NULL) {
fseek(f, 0, SEEK_END);
myDataSize = ftell(f);
if (myDataSize > 0) {
fseek(f, 0, SEEK_SET);
myData = new BYTE[myDataSize];
size_t read = fread(myData, 1, myDataSize, f);
myReadPos = 0;
if (read == myDataSize) {
//loaded = ilLoadL(IL_TYPE_UNKNOWN, lump, read);
ilSetRead(myOpenProc, myCloseProc, myEofProc, myGetcProc, myReadProc, mySeekProc, myTellProc);
loaded = ilLoadFuncs(IL_TYPE_UNKNOWN);
if (!loaded) {
printf("test_ilLoadFuncs: Failed to load " PathCharMod "\n", sourceFN);
++errors;
}
} else {
printf("test_ilLoadFuncs: Failed to read " PathCharMod "\n", sourceFN);
++errors;
}
delete myData;
}
fclose(f);
} else {
printf("test_ilLoadFuncs: Failed to open %S\n", sourceFN);
++errors;
}
testHeap();
//ilConvertImage(IL_BGR, IL_UNSIGNED_BYTE);
//ilConvertImage(IL_LUMINANCE, IL_UNSIGNED_BYTE);
//iluScale(150, 150, 1);
testHeap();
DeleteFile(targetFN);
//printf("Saving " PathCharMod "\n", targetFN);
if (loaded)
if(!ilSaveImage(targetFN)) {
printf("Failed to save " PathCharMod " after ilLoadFuncs\n", targetFN);
++errors;
}
testHeap();
ilDeleteImage(handle);
}
void test_ilLoadL(wchar_t* sourceFN, wchar_t* targetFN)
{
testHeap();
ilInit();
testHeap();
ILuint handle = ilGenImage();
testHeap();
ilBindImage(handle);
testHeap();
//printf("Loading " PathCharMod "\n", sourceFN);
FILE* f = _wfopen(sourceFN, L"rb");
bool loaded = false;
if (f != NULL) {
fseek(f, 0, SEEK_END);
INT64 size = ftell(f);
if (size > 0) {
fseek(f, 0, SEEK_SET);
char* lump = new char[size];
size_t read = fread(lump, 1, size, f);
if (read == size) {
loaded = ilLoadL(IL_TYPE_UNKNOWN, lump, read);
if (!loaded) {
printf("test_ilLoadL: Failed to load " PathCharMod "\n", sourceFN);
++errors;
}
} else {
printf("test_ilLoadL: Failed to read " PathCharMod "\n", sourceFN);
++errors;
}
delete lump;
}
fclose(f);
} else {
printf("test_ilLoadL: Failed to load %S\n", sourceFN);
++errors;
}
testHeap();
//ilConvertImage(IL_BGR, IL_UNSIGNED_BYTE);
//ilConvertImage(IL_LUMINANCE, IL_UNSIGNED_BYTE);
//iluScale(150, 150, 1);
testHeap();
DeleteFile(targetFN);
//printf("Saving " PathCharMod "\n", targetFN);
if (loaded)
if (!ilSaveImage(targetFN)) {
printf("test_ilLoadL: Failed to save " PathCharMod "\n", targetFN);
++errors;
}
testHeap();
ilDeleteImage(handle);
}
int main(int argc, char* argv[])
{
if(argc < 3)
{
printf("usage: ./memory 100 10");
return 0;
}
testStack(atoi(argv[1]),atoi(argv[2]));
printf("finish function stack test\n");
int* pt = testHeap(atoi(argv[1]),atoi(argv[2]));
printf("finish function heap test\n");
getchar();
int* pt1 = testHeap(atoi(argv[1]),atoi(argv[2]));
printf("finish function heap test\n");
getchar();
delete [] pt;
printf("delete pt heap memory\n");
getchar();
delete [] pt1;
printf("delete pt1 heap memory\n");
getchar();
return 0;
}
void test_ilLoadF(wchar_t* sourceFN, wchar_t* targetFN)
{
testHeap();
ilInit();
testHeap();
ILuint handle = ilGenImage();
testHeap();
ilBindImage(handle);
testHeap();
//printf("Loading " PathCharMod "\n", sourceFN);
bool loaded = false;
//FILE* f = _wfopen(sourceFN, L"rb");
FILE * f;
char buf[10];
_wfopen_s(&f, sourceFN, L"rb");
fread(buf, 1, 10, f);
fseek(f, 0, IL_SEEK_SET);
if (f != NULL) {
loaded = ilLoadF(IL_TYPE_UNKNOWN, f);
if(!loaded) {
printf("test_ilLoadF: Failed to load %S\n", sourceFN);
++errors;
}
} else {
printf("test_ilLoadF: Failed to open %S\n", sourceFN);
++errors;
}
fclose(f);
testHeap();
//ilConvertImage(IL_BGR, IL_UNSIGNED_BYTE);
//ilConvertImage(IL_LUMINANCE, IL_UNSIGNED_BYTE);
//iluScale(150, 150, 1);
testHeap();
DeleteFile(targetFN);
//printf("Saving " PathCharMod "\n", targetFN);
if (loaded)
if (!ilSaveImage(targetFN)) {
printf ("test_ilLoadF: Failed to save %S\n", targetFN);
++errors;
}
testHeap();
ilDeleteImage(handle);
}
void testSavers(const TCHAR* sourceFN, const TCHAR* targetFN)
{
testHeap();
ilInit();
testHeap();
ILuint handle = ilGenImage();
testHeap();
ilBindImage(handle);
testHeap();
if (!ilLoadImage(sourceFN)) {
printf("Failed to load %S using ilLoadImage\n", sourceFN);
++errors;
return;
}
testHeap();
// gif, ico: no save support...
// todo: psd, pcx, tga, tif
testSavers2(IL_BMP, targetFN, L"bmp");
testSavers2(IL_JPG, targetFN, L"jpg");
testSavers2(IL_PNG, targetFN, L"png");
testSavers2(IL_PSD, targetFN, L"psd");
testSavers2(IL_PCX, targetFN, L"pcx");
testSavers2(IL_TGA, targetFN, L"tga");
testSavers2(IL_TIF, targetFN, L"tif");
testSavers2(IL_TGA, targetFN, L"tga");
testSavers2(IL_PCX, targetFN, L"pcx");
testSavers2(IL_PNM, targetFN, L"pnm");
testSavers2(IL_SGI, targetFN, L"sgi");
testSavers2(IL_WBMP, targetFN, L"wbmp");
testSavers2(IL_MNG, targetFN, L"mng");
testSavers2(IL_VTF, targetFN, L"vtf");
testHeap();
ilDeleteImage(handle);
}
int main(){
testHeap();
return 0;
}
void ApexQuadricSimplifier::collapseEdge(QuadricEdge& edge)
{
uint32_t vNr0 = edge.vertexNr[0];
uint32_t vNr1 = edge.vertexNr[1];
QuadricVertex* qv0 = mVertices[vNr0];
QuadricVertex* qv1 = mVertices[vNr1];
PX_ASSERT(qv0->bDeleted == 0);
PX_ASSERT(qv1->bDeleted == 0);
//FILE* f = NULL;
//fopen_s(&f, "c:\\collapse.txt", "a");
//fprintf_s(f, "Collapse Vertex %d -> %d\n", vNr1, vNr0);
// contract edge to the vertex0
qv0->pos = qv0->pos * (1.0f - edge.ratio) + qv1->pos * edge.ratio;
qv0->q += qv1->q;
// merge the edges
for (uint32_t i = 0; i < qv1->mEdges.size(); i++)
{
QuadricEdge& ei = mEdges[qv1->mEdges[i]];
uint32_t vi = ei.otherVertex(vNr1);
if (vi == vNr0)
{
continue;
}
// test whether we already have this neighbor
bool found = false;
for (uint32_t j = 0; j < qv0->mEdges.size(); j++)
{
QuadricEdge& ej = mEdges[qv0->mEdges[j]];
if (ej.otherVertex(vNr0) == vi)
{
found = true;
break;
}
}
if (found)
{
mVertices[vi]->removeEdge((int32_t)qv1->mEdges[i]);
ei.deleted = true;
if (ei.heapPos >= 0)
{
heapRemove((uint32_t)ei.heapPos, false);
}
#if TESTING
testHeap();
#endif
}
else
{
ei.replaceVertex(vNr1, vNr0);
qv0->mEdges.pushBack(qv1->mEdges[i]);
}
}
// remove common edge and update adjacent edges
for (int32_t i = (int32_t)qv0->mEdges.size() - 1; i >= 0; i--)
{
QuadricEdge& ei = mEdges[qv0->mEdges[(uint32_t)i]];
if (ei.otherVertex(vNr0) == vNr1)
{
qv0->mEdges.replaceWithLast((uint32_t)i);
}
else
{
computeCost(ei);
if (ei.heapPos >= 0)
{
heapUpdate((uint32_t)ei.heapPos);
}
#if TESTING
testHeap();
#endif
}
}
// delete collapsed triangles
for (int32_t i = (int32_t)qv0->mTriangles.size() - 1; i >= 0; i--)
{
uint32_t triangleIndex = qv0->mTriangles[(uint32_t)i];
QuadricTriangle& t = mTriangles[triangleIndex];
if (!t.deleted && t.containsVertex(vNr1))
{
mNumDeletedTriangles++;
t.deleted = true;
//fprintf_s(f, "Delete Triangle %d\n", triangleIndex);
PX_ASSERT(t.containsVertex(vNr0));
for (uint32_t j = 0; j < 3; j++)
{
mVertices[t.vertexNr[j]]->removeTriangle((int32_t)triangleIndex);
//fprintf_s(f, " v %d\n", t.vertexNr[j]);
}
}
}
// update triangles
for (uint32_t i = 0; i < qv1->mTriangles.size(); i++)
{
QuadricTriangle& t = mTriangles[qv1->mTriangles[i]];
if (t.deleted)
{
continue;
}
if (t.containsVertex(vNr1))
{
qv0->mTriangles.pushBack(qv1->mTriangles[i]);
}
t.replaceVertex(vNr1, vNr0);
}
mNumDeletedVertices += qv1->bDeleted == 1 ? 0 : 1;
qv1->bDeleted = 1;
edge.deleted = true;
//fclose(f);
#if TESTING
testMesh();
testHeap();
#endif
}
uint32_t ApexQuadricSimplifier::simplify(uint32_t subdivision, int32_t maxSteps, float maxError, IProgressListener* progressListener)
{
float maxLength = 0.0f;
uint32_t nbCollapsed = 0;
if (subdivision > 0)
{
maxLength = (mBounds.minimum - mBounds.maximum).magnitude() / subdivision;
}
uint32_t progressCounter = 0;
uint32_t maximum = maxSteps >= 0 ? maxSteps : mHeap.size();
HierarchicalProgressListener progress(100, progressListener);
progress.setSubtaskWork(90, "Isomesh simplicifaction");
#if TESTING
testHeap();
#endif
while (maxSteps == -1 || (maxSteps-- > 0))
{
if ((++progressCounter & 0xff) == 0)
{
const int32_t percent = (int32_t)(100 * progressCounter / maximum);
progress.setProgress(percent);
}
bool edgeFound = false;
QuadricEdge* e = NULL;
while (mHeap.size() - mNumDeletedHeapElements > 1)
{
e = mHeap[1];
if (maxError >= 0 && e->cost > maxError)
{
// get me out of here
edgeFound = false;
break;
}
if (legalCollapse(*e, maxLength))
{
heapRemove(1, false);
#if TESTING
testHeap();
#endif
edgeFound = true;
break;
}
uint32_t vNr0 = e->vertexNr[0];
uint32_t vNr1 = e->vertexNr[1];
QuadricVertex* qv0 = mVertices[vNr0];
QuadricVertex* qv1 = mVertices[vNr1];
heapRemove(1, qv0->bDeleted == 0 && qv1->bDeleted == 0);
#if TESTING
testHeap();
#endif
}
if (!edgeFound)
{
break;
}
collapseEdge(*e);
nbCollapsed++;
}
progress.completeSubtask();
progress.setSubtaskWork(10, "Heap rebuilding");
progressCounter = mNumDeletedHeapElements;
while (mNumDeletedHeapElements > 0)
{
if ((mNumDeletedHeapElements & 0x7f) == 0)
{
const int32_t percent = (int32_t)(100 * (progressCounter - mNumDeletedHeapElements) / progressCounter);
progress.setProgress(percent);
}
#if TESTING
testHeap();
#endif
mNumDeletedHeapElements--;
heapUpdate(mHeap.size() - 1 - mNumDeletedHeapElements);
}
progress.completeSubtask();
#if TESTING
testHeap();
#endif
return nbCollapsed;
}
int main(int argc, char *argv[])
{
size_t size;
int version;
CMEM_BlockAttrs attrs;
int i;
int c;
non_interactive_flag = FALSE;
while ((c = getopt(argc, argv, "n")) != -1) {
switch (c) {
case 'n':
non_interactive_flag = TRUE;
break;
default:
fprintf(stderr, "Usage: %s [-n] <Number of bytes to allocate>\n",
argv[0]);
fprintf(stderr,
" -n: non-interactive mode (no ENTER prompts)\n");
exit(EXIT_FAILURE);
}
}
if ((argc - optind + 1) != 2) {
fprintf(stderr, "Usage: %s [-n] <Number of bytes to allocate>\n",
argv[0]);
fprintf(stderr, " -n: non-interactive mode (no ENTER prompts)\n");
exit(EXIT_FAILURE);
}
errno = 0;
size = strtol(argv[optind], NULL, 0);
if (errno) {
fprintf(stderr, "Bad argument ('%s'), strtol() set errno %d\n",
argv[optind], errno);
exit(EXIT_FAILURE);
}
/* First initialize the CMEM module */
if (CMEM_init() == -1) {
fprintf(stderr, "Failed to initialize CMEM\n");
exit(EXIT_FAILURE);
}
printf("CMEM initialized.\n");
version = CMEM_getVersion();
if (version == -1) {
fprintf(stderr, "Failed to retrieve CMEM version\n");
exit(EXIT_FAILURE);
}
printf("CMEM version = 0x%x\n", version);
testMap(size);
testAllocPhys(size);
testCMA(size);
if (CMEM_getNumBlocks(&nblocks)) {
fprintf(stderr, "Failed to retrieve number of blocks\n");
exit(EXIT_FAILURE);
}
printf("\n# of CMEM blocks (doesn't include possible CMA global 'block'): %d\n", nblocks);
if (nblocks) {
for (i = 0; i < nblocks; i++) {
if (CMEM_getBlockAttrs(i, &attrs) == -1) {
fprintf(stderr, "Failed to retrieve CMEM memory block %d bounds\n", i);
}
else {
printf("CMEM memory block %d: phys start = %#llx, size = %#llx\n",
i, (unsigned long long)attrs.phys_base, attrs.size);
}
testHeap(size, i);
testHeap(size, i);
testPools(size, i);
testPools(size, i);
testCache(size, i);
}
}
else {
printf(" no physical block found, not performing block-based testing\n");
}
/* block 'nblocks' is the special CMEM CMA "block" */
testPools(size, CMEM_CMABLOCKID);
printf("\nexiting...\n");
if (CMEM_exit() < 0) {
fprintf(stderr, "Failed to finalize the CMEM module\n");
}
printf("...test done\n");
exit(EXIT_SUCCESS);
}