Changes for 1.1.1

See README.md

1 files changed, 286 insertions, 0 deletions

diff --git a/test/src/perf/DamagePerfTests.cpp b/test/src/perf/DamagePerfTests.cpp
new file mode 100644
index 0000000..df72b45
--- /dev/null
+++ b/test/src/perf/DamagePerfTests.cpp
@@ -0,0 +1,286 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2016-2017 NVIDIA Corporation. All rights reserved.
+
+
+#include "BlastBasePerfTest.h"
+#include "NvBlastExtDamageShaders.h"
+#include "NvBlastExtSerialization.h"
+#include "NvBlastTime.h"
+#include "PxVec3.h"
+#include "PxBounds3.h"
+#include <memory>
+#include <random>
+#include <cstdio>
+
+using namespace Nv::Blast;
+using namespace physx;
+
+static void blast
+(
+	std::set<NvBlastActor*>& actorsToDamage,
+	GeneratorAsset* testAsset,
+	NvBlastExtDamageAccelerator* accelerator,
+	GeneratorAsset::Vec3 localPos,
+	float minRadius, float maxRadius,
+	float compressiveDamage,
+	std::vector<uint32_t>& history,
+	NvBlastTimers& timers)
+{
+	std::vector<NvBlastChunkFractureData> chunkEvents; /* num lower-support chunks + bonds */
+	std::vector<NvBlastBondFractureData> bondEvents; /* num lower-support chunks + bonds */
+	chunkEvents.resize(testAsset->solverChunks.size());
+	bondEvents.resize(testAsset->solverBonds.size());
+
+	NvBlastExtRadialDamageDesc damage = {
+		compressiveDamage,
+		{ localPos.x, localPos.y, localPos.z },
+		minRadius,
+		maxRadius
+	};
+
+	NvBlastExtMaterial material;
+
+	NvBlastExtProgramParams programParams =
+	{
+		&damage,
+		&material,
+		accelerator
+	};
+
+	NvBlastDamageProgram program = {
+		NvBlastExtFalloffGraphShader,
+		nullptr
+	};
+
+	std::vector<char> splitScratch;
+	std::vector<NvBlastActor*> newActors(testAsset->solverChunks.size());
+
+	size_t totalNewActorsCount = 0;
+	for (std::set<NvBlastActor*>::iterator k = actorsToDamage.begin(); k != actorsToDamage.end();)
+	{
+		NvBlastActor* actor = *k;
+
+		NvBlastFractureBuffers events = { (uint32_t)bondEvents.size(), (uint32_t)chunkEvents.size(), bondEvents.data(), chunkEvents.data() };
+
+		NvBlastActorGenerateFracture(&events, actor, program, &programParams, nullptr, &timers);
+		NvBlastActorApplyFracture(nullptr, actor, &events, nullptr, &timers);
+
+		bool removeActor = false;
+
+		if (events.bondFractureCount + events.chunkFractureCount > 0)
+		{
+			history.push_back(events.bondFractureCount + events.chunkFractureCount);
+
+			splitScratch.resize((size_t)NvBlastActorGetRequiredScratchForSplit(actor, nullptr));
+			NvBlastActorSplitEvent result;
+			result.deletedActor = nullptr;
+			result.newActors = &newActors[totalNewActorsCount];
+			const size_t bufferSize = newActors.size() - totalNewActorsCount;
+			const size_t newActorsCount = NvBlastActorSplit(&result, actor, (uint32_t)bufferSize, splitScratch.data(), nullptr, &timers);
+			totalNewActorsCount += newActorsCount;
+			removeActor = newActorsCount > 0;
+		}
+
+		if (removeActor)
+		{
+			k = actorsToDamage.erase(k);
+		}
+		else
+		{
+			++k;
+		}
+	}
+
+	for (size_t i = 0; i < totalNewActorsCount; ++i)
+	{
+		actorsToDamage.insert(newActors[i]);
+	}
+}
+
+typedef BlastBasePerfTest<NvBlastMessage::Warning, 1> BlastBasePerfTestStrict;
+
+
+struct PerfResults
+{
+	int64_t totalTime;
+	int64_t createTime;
+};
+
+class PerfTest : public BlastBasePerfTestStrict
+{
+public:
+
+  NvBlastAsset* loadAsset(const char* path, ExtSerialization* ser)
+  {
+    std::ifstream infileStream(path, std::ios::binary);
+    if (!infileStream.is_open())
+    {
+      return nullptr;
+    }
+    const std::vector<char> inBuffer((std::istreambuf_iterator<char>(infileStream)), std::istreambuf_iterator<char>());
+    infileStream.close();
+
+    NvBlastAsset* asset = static_cast<NvBlastAsset*>(ser->deserializeFromBuffer(inBuffer.data(), inBuffer.size()));
+
+    return asset;
+  }
+
+	PerfResults damageLeafSupportActors(const char* testName, uint32_t assetCount, uint32_t familyCount, uint32_t damageCount, int accelType, std::vector<uint32_t>& history)
+	{
+		PerfResults results;
+		results.totalTime = 0;
+		results.createTime = 0;
+
+		const float compressiveDamage = 1.0f;
+		const uint32_t minChunkCount = 1000;
+		const uint32_t maxChunkCount = 100000;
+
+		srand(0);
+
+		for (uint32_t assetNum = 0; assetNum < assetCount; ++assetNum)
+		{
+			GeneratorAsset cube;
+			NvBlastAssetDesc desc;
+			generateRandomCube(cube, desc, minChunkCount, maxChunkCount);
+
+			{
+				std::vector<char> scratch;
+				physx::PxBounds3 bounds = physx::PxBounds3::empty();
+#if 1
+				scratch.resize((size_t)NvBlastGetRequiredScratchForCreateAsset(&desc, messageLog));
+				void* mem = alignedZeroedAlloc(NvBlastGetAssetMemorySize(&desc, messageLog));
+				NvBlastAsset* asset = NvBlastCreateAsset(mem, &desc, scratch.data(), messageLog);
+				EXPECT_TRUE(asset != nullptr);
+				bounds = physx::PxBounds3::centerExtents(physx::PxVec3(0, 0, 0), physx::PxVec3(cube.extents.x, cube.extents.y, cube.extents.z));
+#else
+				// load asset
+				NvBlastAsset* asset = nullptr;
+				ExtSerialization* ser = NvBlastExtSerializationCreate();
+				for (int s = 0; s < 5 && !asset; s++)
+				{
+					asset = loadAsset(&"../../../../../test/assets/table.blast"[s * 3], ser);
+				}
+				EXPECT_TRUE(asset != nullptr);
+				ser->release();
+				uint32_t bc = NvBlastAssetGetBondCount(asset, messageLog);
+				const NvBlastBond* bonds = NvBlastAssetGetBonds(asset, messageLog);
+				for (uint32_t i = 0; i < bc; i++)
+				{
+					bounds.include(reinterpret_cast<const physx::PxVec3&>(bonds[i].centroid));
+				}
+#endif
+
+				Nv::Blast::Time t;
+				NvBlastExtDamageAccelerator* accelerator = NvBlastExtDamageAcceleratorCreate(asset, accelType);
+				results.createTime += t.getElapsedTicks();
+
+				// Generate familes
+				for (uint32_t familyNum = 0; familyNum < familyCount; ++familyNum)
+				{
+					// create actor
+					NvBlastActorDesc actorDesc;
+					actorDesc.initialBondHealths = nullptr;
+					actorDesc.uniformInitialBondHealth = 1.0f;
+					actorDesc.initialSupportChunkHealths = nullptr;
+					actorDesc.uniformInitialLowerSupportChunkHealth = 1.0f;
+					void* mem = alignedZeroedAlloc(NvBlastAssetGetFamilyMemorySize(asset, messageLog));
+					NvBlastFamily* family = NvBlastAssetCreateFamily(mem, asset, messageLog);
+					scratch.resize((size_t)NvBlastFamilyGetRequiredScratchForCreateFirstActor(family, messageLog));
+					EXPECT_TRUE(family != nullptr);
+					NvBlastActor* actor = NvBlastFamilyCreateFirstActor(family, &actorDesc, scratch.data(), messageLog);
+					EXPECT_TRUE(actor != nullptr);
+
+					// Generate damage
+					std::set<NvBlastActor*> actors;
+					actors.insert(actor);
+					for (uint32_t damageNum = 0; damageNum < damageCount; ++damageNum)
+					{
+						GeneratorAsset::Vec3 localPos = GeneratorAsset::Vec3((float)rand() / RAND_MAX - 0.5f, (float)rand() / RAND_MAX - 0.5f, (float)rand() / RAND_MAX - 0.5f) * 2;
+						localPos.x *= bounds.getExtents().x;
+						localPos.y *= bounds.getExtents().y;
+						localPos.z *= bounds.getExtents().z;
+						const float relativeDamageRadius = (float)rand() / RAND_MAX * bounds.getExtents().maxElement();
+
+						NvBlastTimers timers;
+						NvBlastTimersReset(&timers);
+						blast(actors, &cube, accelerator, localPos, relativeDamageRadius, relativeDamageRadius*1.2f, compressiveDamage, history, timers);
+						const std::string timingName = std::string(testName) + " asset " + std::to_string(assetNum) + " family " + std::to_string(familyNum) + " damage " + std::to_string(damageNum) + " accel " + std::to_string(accelType);
+						BlastBasePerfTestStrict::reportData(timingName + " material", timers.material);
+						history.push_back((uint32_t)actors.size());
+						results.totalTime += timers.material;
+						history.push_back(0); // separator
+					}
+
+					// Release remaining actors
+					std::for_each(actors.begin(), actors.end(), [](NvBlastActor* a) { NvBlastActorDeactivate(a, messageLog); });
+					actors.clear();
+
+					alignedFree(family);
+				}
+
+				if (accelerator)
+					accelerator->release();
+
+				// Release asset data
+				alignedFree(asset);
+			}
+		}
+
+		return results;
+	}
+};
+
+
+// Tests
+TEST_F(PerfTest, DISABLED_DamageRadialSimple)
+{
+	const int trialCount = 10;
+	std::cout << "Trial (of " << trialCount << "): ";
+	for (int trial = 1; trial <= trialCount; ++trial)
+	{
+		if (trial % 100 == 0)
+		{
+			std::cout << trial << ".. ";
+			std::cout.flush();
+		}
+		std::vector<uint32_t> history1, history2;
+
+		uint32_t assetCount = 4;
+		uint32_t familyCount = 4;
+		uint32_t damageCount = 4;
+
+		PerfResults results0 = damageLeafSupportActors(test_info_->name(), assetCount, familyCount, damageCount, 0, history1);
+		BlastBasePerfTestStrict::reportData("DamageRadialSimple total0 " , results0.totalTime);
+		BlastBasePerfTestStrict::reportData("DamageRadialSimple create0 ", results0.createTime);
+		PerfResults results1 = damageLeafSupportActors(test_info_->name(), assetCount, familyCount, damageCount, 1, history2);
+		BlastBasePerfTestStrict::reportData("DamageRadialSimple total1 ", results1.totalTime);
+		BlastBasePerfTestStrict::reportData("DamageRadialSimple create1 ", results1.createTime);
+
+		EXPECT_TRUE(history1 == history2);
+	}
+	std::cout << "done." << std::endl;
+}