Out of memory is fatal. Don't handle OOM errors

include/anki/gr/gl/RenderingThread.h

@@ -15,7 +15,7 @@ namespace anki {
 /// @addtogroup opengl
 /// @{
 
-#define ANKI_GL_DISABLE_ASYNC 0
+#define ANKI_DISABLE_GL_RENDERING_THREAD 0
 
 /// Command queue. It's essentialy a queue of command buffers waiting for 
 /// execution and a server

include/anki/physics/PhysicsWorld.h

@@ -115,15 +115,8 @@ inline T* PhysicsWorld::newObjectInternal(TContainer& cont, TArgs&&... args)
 	ChainAllocator<T> al = m_alloc;
 
 	T* ptr = al.template newInstance<T>(this);
-	if(ptr)
-	{
-		err = ptr->create(std::forward<TArgs>(args)...);
-	}
-	else
-	{
-		err = ErrorCode::OUT_OF_MEMORY;
-	}
-
+	err = ptr->create(std::forward<TArgs>(args)...);
+	
 	if(!err)
 	{
 		cont.pushBack(m_alloc, ptr);

include/anki/resource/AsyncLoader.h

@@ -65,10 +65,6 @@ Error AsyncLoader::newTask(TArgs&&... args)
 {
 	TTask* newTask = m_alloc.template newInstance<TTask>(
 		std::forward<TArgs>(args)...);
-	if(newTask == nullptr)
-	{
-		return ErrorCode::OUT_OF_MEMORY;
-	}
 
 	// Append task to the list
 	{

include/anki/resource/ResourcePointer.inl.h

@@ -31,12 +31,6 @@ Error ResourcePointer<T, TResourceManager>::load(
 			alloc.allocate(
 			sizeof(ControlBlock) + len, &alignment));
 
-		if(!m_cb)
-		{
-			ANKI_LOGE("OOM when loading resource");
-			return ErrorCode::OUT_OF_MEMORY;
-		}
-
 		// Construct
 		alloc.construct(m_cb, alloc);
 

src/collision/ConvexHullShape.cpp

@@ -64,16 +64,10 @@ Error ConvexHullShape::initStorage(CollisionAllocator<U8>& alloc, U pointCount)
 
 	m_points = 
 		reinterpret_cast<Vec4*>(alloc.allocate(pointCount * sizeof(Vec4)));
-	if(m_points)
-	{
-		m_alloc = alloc;
-		m_ownsTheStorage = true;
-		m_pointsCount = pointCount;
-	}
-	else
-	{
-		return ErrorCode::OUT_OF_MEMORY;
-	}
+	
+	m_alloc = alloc;
+	m_ownsTheStorage = true;
+	m_pointsCount = pointCount;
 
 	return ErrorCode::NONE;
 }

src/core/App.cpp

@@ -165,7 +165,6 @@ Error App::createInternal(const ConfigSet& config_,
 	nwinit.m_fullscreenDesktopRez = config.get("fullscreenDesktopResolution");
 	nwinit.m_debugContext = config.get("debugContext");
 	m_window = m_heapAlloc.newInstance<NativeWindow>();
-	if(!m_window) return ErrorCode::OUT_OF_MEMORY;
 
 	ANKI_CHECK(m_window->create(nwinit, m_heapAlloc));
 
@@ -176,7 +175,6 @@ Error App::createInternal(const ConfigSet& config_,
 	// Input
 	//
 	m_input = m_heapAlloc.newInstance<Input>();
-	if(!m_input) return ErrorCode::OUT_OF_MEMORY;
 
 	ANKI_CHECK(m_input->create(m_window));
 
@@ -184,16 +182,11 @@ Error App::createInternal(const ConfigSet& config_,
 	// Threadpool
 	//
 	m_threadpool = m_heapAlloc.newInstance<Threadpool>(getCpuCoresCount());
-	if(!m_threadpool) return ErrorCode::OUT_OF_MEMORY;
 
 	//
 	// GL
 	//
 	m_gr = m_heapAlloc.newInstance<GrManager>();
-	if(!m_gr)
-	{
-		return ErrorCode::OUT_OF_MEMORY;
-	}
 
 	GrManagerInitializer grInit;
 	grInit.m_allocCallback = m_allocCb;
@@ -212,10 +205,6 @@ Error App::createInternal(const ConfigSet& config_,
 	// Physics
 	//
 	m_physics = m_heapAlloc.newInstance<PhysicsWorld>();
-	if(!m_physics)
-	{
-		return ErrorCode::OUT_OF_MEMORY;
-	}
 
 	ANKI_CHECK(m_physics->create(m_allocCb, m_allocCbData));
 
@@ -231,7 +220,6 @@ Error App::createInternal(const ConfigSet& config_,
 	rinit.m_allocCallbackData = m_allocCbData;
 	rinit.m_tempAllocatorMemorySize = 1024 * 1024 * 4;
 	m_resources = m_heapAlloc.newInstance<ResourceManager>();
-	if(!m_resources) return ErrorCode::OUT_OF_MEMORY;
 
 	ANKI_CHECK(m_resources->create(rinit));
 
@@ -245,7 +233,6 @@ Error App::createInternal(const ConfigSet& config_,
 	}
 
 	m_renderer = m_heapAlloc.newInstance<MainRenderer>();
-	if(!m_renderer) return ErrorCode::OUT_OF_MEMORY;
 
 	ANKI_CHECK(m_renderer->create(
 		m_threadpool,
@@ -260,7 +247,6 @@ Error App::createInternal(const ConfigSet& config_,
 
 	// Scene
 	m_scene = m_heapAlloc.newInstance<SceneGraph>();
-	if(!m_scene) return ErrorCode::OUT_OF_MEMORY;
 
 	ANKI_CHECK(m_scene->create(m_allocCb, m_allocCbData, 
 		config.get("sceneFrameAllocatorSize"), m_threadpool, m_resources,
@@ -268,7 +254,6 @@ Error App::createInternal(const ConfigSet& config_,
 
 	// Script
 	m_script = m_heapAlloc.newInstance<ScriptManager>();
-	if(!m_script) return ErrorCode::OUT_OF_MEMORY;
 		
 	ANKI_CHECK(m_script->create(m_allocCb, m_allocCbData, m_scene));
 

src/core/NativeWindowSdl.cpp

@@ -19,7 +19,6 @@ Error NativeWindow::create(Initializer& init, HeapAllocator<U8>& alloc)
 {
 	m_alloc = alloc;
 	m_impl = m_alloc.newInstance<NativeWindowImpl>();
-	if(!m_impl) return ErrorCode::OUT_OF_MEMORY;
 
 	if(SDL_Init(INIT_SUBSYSTEMS) != 0)
 	{

src/gr/gl/GrManagerImpl.cpp

@@ -30,10 +30,6 @@ Error GrManagerImpl::create(GrManagerInitializer& init)
 	// Create thread
 	m_thread = 
 		m_manager->getAllocator().newInstance<RenderingThread>(m_manager);
-	if(!m_thread)
-	{
-		err = ErrorCode::OUT_OF_MEMORY;
-	}
 
 	// Start it
 	if(!err)

src/gr/gl/RenderingThread.cpp

@@ -51,7 +51,7 @@ void RenderingThread::flushCommandBuffer(CommandBufferHandle& commands)
 {
 	commands.get().makeImmutable();
 
-#if !ANKI_GL_DISABLE_ASYNC
+#if !ANKI_DISABLE_GL_RENDERING_THREAD
 	{
 		LockGuard<Mutex> lock(m_mtx);
 
@@ -84,7 +84,7 @@ void RenderingThread::flushCommandBuffer(CommandBufferHandle& commands)
 //==============================================================================
 void RenderingThread::finishCommandBuffer(CommandBufferHandle& commands)
 {
-#if !ANKI_GL_DISABLE_ASYNC
+#if !ANKI_DISABLE_GL_RENDERING_THREAD
 	flushCommandBuffer(commands);
 
 	syncClientServer();
@@ -120,7 +120,7 @@ Error RenderingThread::start(
 		m_swapBuffersCommands.pushBackUserCommand(swapBuffersInternal, this);
 	}
 
-#if !ANKI_GL_DISABLE_ASYNC
+#if !ANKI_DISABLE_GL_RENDERING_THREAD
 	Bool threadStarted = false;
 	if(!err)
 	{
@@ -153,7 +153,7 @@ Error RenderingThread::start(
 //==============================================================================
 void RenderingThread::stop()
 {
-#if !ANKI_GL_DISABLE_ASYNC
+#if !ANKI_DISABLE_GL_RENDERING_THREAD
 	{
 		LockGuard<Mutex> lock(m_mtx);
 		m_renderingThreadSignal = 1;
@@ -276,7 +276,7 @@ void RenderingThread::threadLoop()
 //==============================================================================
 void RenderingThread::syncClientServer()
 {
-#if !ANKI_GL_DISABLE_ASYNC
+#if !ANKI_DISABLE_GL_RENDERING_THREAD
 	flushCommandBuffer(m_syncCommands);
 	m_syncBarrier.wait();
 #endif
@@ -305,7 +305,7 @@ Error RenderingThread::swapBuffersInternal(void* ptr)
 //==============================================================================
 void RenderingThread::swapBuffers()
 {
-#if !ANKI_GL_DISABLE_ASYNC
+#if !ANKI_DISABLE_GL_RENDERING_THREAD
 	// Wait for the rendering thread to finish swap buffers...
 	{
 		LockGuard<Mutex> lock(m_frameMtx);

src/input/InputSdl.cpp

@@ -22,7 +22,6 @@ Error Input::init(NativeWindow* nativeWindow)
 		m_nativeWindow->_getAllocator();
 
 	m_impl = m_nativeWindow->_getAllocator().newInstance<InputImpl>(alloc);
-	if(!m_impl) return ErrorCode::OUT_OF_MEMORY;
 
 	//impl
 	m_impl->m_sdlToAnki[SDLK_RETURN] = KeyCode::RETURN;

src/renderer/Dbg.cpp

@@ -64,10 +64,6 @@ Error Dbg::init(const ConfigSet& initializer)
 	if(!err)
 	{
 		m_drawer = getAllocator().newInstance<DebugDrawer>();
-		if(m_drawer == nullptr)
-		{
-			err = ErrorCode::OUT_OF_MEMORY;
-		}
 	}
 
 	if(!err)
@@ -78,10 +74,6 @@ Error Dbg::init(const ConfigSet& initializer)
 	if(!err)
 	{
 		m_sceneDrawer = getAllocator().newInstance<SceneDebugDrawer>(m_drawer);
-		if(m_sceneDrawer == nullptr)
-		{
-			err = ErrorCode::OUT_OF_MEMORY;
-		}
 	}
 
 	if(!err)

src/resource/Model.cpp

@@ -341,11 +341,6 @@ Error Model::load(const CString& filename, ResourceInitializer& init)
 			ANKI_LOGE("Incorrect collision type");
 			return ErrorCode::USER_DATA;
 		}
-
-		if(m_physicsShape == nullptr)
-		{
-			return ErrorCode::OUT_OF_MEMORY;
-		}
 	}
 
 	// <modelPatches>

src/resource/ResourceManager.cpp

@@ -90,11 +90,6 @@ Error ResourceManager::create(Initializer& init)
 
 	// Init the thread
 	m_asyncLoader = m_alloc.newInstance<AsyncLoader>();
-	if(m_asyncLoader == nullptr)
-	{
-		return ErrorCode::OUT_OF_MEMORY;
-	}
-
 	err = m_asyncLoader->create(m_alloc);
 
 	return err;

src/resource/TextureResource.cpp

@@ -44,10 +44,6 @@ Error TextureResource::load(const CString& filename, ResourceInitializer& rinit)
 
 	// Load image
 	Image* img = rinit.m_alloc.newInstance<Image>(rinit.m_alloc);
-	if(img == nullptr)
-	{
-		return ErrorCode::OUT_OF_MEMORY;
-	}
 
 	err = img->load(filename, rinit.m_resources.getMaxTextureSize());
 	if(err)

src/scene/RenderComponent.cpp

@@ -30,13 +30,8 @@ struct CreateNewRenderComponentVariableVisitor
 		RenderComponentVariableTemplate<Type>* rvar =
 			m_alloc.newInstance<RenderComponentVariableTemplate<Type>>(m_mvar);
 
-		if(rvar)
-		{
-			(*m_vars)[(*m_count)++] = rvar;
-			return ErrorCode::NONE;
-		}
-
-		return ErrorCode::OUT_OF_MEMORY;
+		(*m_vars)[(*m_count)++] = rvar;
+		return ErrorCode::NONE;
 	}
 };
 

src/scene/Visibility.cpp

@@ -199,10 +199,6 @@ void VisibilityTestTask::test(SceneNode& testedNode,
 		ANKI_ASSERT(count < MAX_U8);
 		visibleNode.m_spatialsCount = count;
 		visibleNode.m_spatialIndices = alloc.newArray<U8>(count);
-		if(ANKI_UNLIKELY(visibleNode.m_spatialIndices == nullptr))
-		{
-			return ErrorCode::OUT_OF_MEMORY;
-		}
 
 		for(U i = 0; i < count; i++)
 		{