C++ Atomic类代码示例

void XAsset::createD3HierarchyClasses(Clump* clump, D3DXFRAME* frame)
{
    Frame* f = static_cast<Frame*>( frame );
    while( f->pMeshContainer )
    {
        Mesh* mesh = static_cast<Mesh*>( f->pMeshContainer );
        
        const char* geometryName = mesh->Name;
        if( !geometryName ) geometryName = "NamelessGeometry";
        Geometry* geometry = new Geometry( mesh, geometryName );

        Atomic* atomic = new Atomic;
        atomic->setGeometry( geometry );
        atomic->setFrame( f );

        clump->add( atomic );

        f->pMeshContainer = f->pMeshContainer->pNextMeshContainer;
    }

    if( f->pFrameFirstChild ) 
    {
        static_cast<Frame*>( f->pFrameFirstChild )->pParentFrame = f;
        createD3HierarchyClasses( clump, f->pFrameFirstChild );
    }

    if( f->pFrameSibling ) 
    {
        static_cast<Frame*>( f->pFrameSibling )->pParentFrame = f->pParentFrame;
        createD3HierarchyClasses( clump, f->pFrameSibling );
    }
}

engine::IAtomic* BSP::setAtomicWorldCB(engine::IAtomic* atomic, void* data)
{
    Atomic* a = dynamic_cast<Atomic*>( atomic );
    a->_bsp = data;
    a->onUpdate();
    return atomic;
}

BOOST_AUTO_TEST_CASE_TEMPLATE(SwapTest, T, AtomicSwapTypes)
{
    Atomic<T> value = 102;
    T const old = value.Swap(T(123));
    BOOST_CHECK_EQUAL(old, T(102));
    BOOST_CHECK_EQUAL(value, T(123));
}

void
Triangle_Processor::Divide(unsigned int N, Stack<AtomicRegion>&  Offspring)
  {
  Stack<Triangle> Parts;  
  Vector<unsigned int> DiffOrder(Diffs.Size());
  real NewVolume;
  
  switch(N)
    {
    case 2: 
    {    
    NewVolume = Geometry().Volume()/2;

    TheRule->ComputeDiffs(LocalIntegrand(),Geometry(),Diffs);

    // Sort the differences in descending order.
    for (unsigned int ik=0 ; ik<=2 ; ik++)  { DiffOrder[ik] = ik; }
    for (unsigned int i=0 ; i<=1 ; i++)  
      {
      for (unsigned int k=i+1 ; k<=2 ; k++)
         if (Diffs[DiffOrder[k]]>Diffs[DiffOrder[i]])
            {
            unsigned int h = DiffOrder[i];
            DiffOrder[i] = DiffOrder[k];
            DiffOrder[k] = h;
            }
      }
    TheDivisor2->Apply (Geometry(),Parts,DiffOrder);
    break;
    }
  
    case 4:
    {
    NewVolume = Geometry().Volume()/4;
    TheDivisor4->Apply (Geometry(),Parts,DiffOrder);
    break;
    }
  
    default:
      {
        NewVolume = Geometry().Volume()/N; 
        Error(True,"This kind of subdivision is not implemented");
      }
    }
  
  
  for (unsigned int i =0;i<N;i++)
    {
    Triangle* g = Parts.Pop();
    g->Volume(NewVolume);
    Processor<Triangle>* p = Descendant();
    Atomic<Triangle>* a = new Atomic<Triangle>(g,p);
    a->LocalIntegrand(&LocalIntegrand());
    Offspring.Push(a);
    };
    
  return;

  }

void ObjectRenderer::renderInstance(InstanceObject* instance,
                                    RenderList& outList) {
    const auto& atomic = instance->getAtomic();
    if (!atomic) {
        return;
    }

    // Only draw visible objects
    if (!instance->getVisible()) {
        return;
    }

    auto modelinfo = instance->getModelInfo<SimpleModelInfo>();

    // Handles times provided by TOBJ data
    const auto currentHour = m_world->getHour();
    if (modelinfo->timeOff < modelinfo->timeOn) {
        if (currentHour >= modelinfo->timeOff &&
            currentHour < modelinfo->timeOn)
            return;
    } else {
        if (currentHour >= modelinfo->timeOff ||
            currentHour < modelinfo->timeOn)
            return;
    }

    float mindist = glm::length(instance->getPosition() - m_camera.position) /
                    kDrawDistanceFactor;

    if (mindist > modelinfo->getLargestLodDistance()) {
        culled++;
        return;
    }

    if (modelinfo->isBigBuilding() &&
        mindist < modelinfo->getNearLodDistance() &&
        mindist < kMagicLODDistance) {
        auto related = modelinfo->related();
        if (!related || related->isLoaded()) {
            culled++;
            return;
        }
    }

    Atomic* distanceatomic =
        modelinfo->getDistanceAtomic(mindist / kDrawDistanceFactor);
    if (!distanceatomic) {
        return;
    }

    if (atomic->getGeometry() != distanceatomic->getGeometry()) {
        atomic->setGeometry(distanceatomic->getGeometry());
    }

    // Render the atomic the instance thinks it should be
    renderAtomic(atomic.get(), glm::mat4(), instance, outList);
}

SharedMemory::SharedMemory()
  : mAllocSize(0)
  , mMappedSize(0)
{
  static Atomic<uint32_t> registered;
  if (registered.compareExchange(0, 1)) {
    RegisterStrongMemoryReporter(new ShmemAllocatedReporter());
    RegisterStrongMemoryReporter(new ShmemMappedReporter());
  }
}

SharedMemory::SharedMemory()
  : mAllocSize(0)
  , mMappedSize(0)
{
  MOZ_COUNT_CTOR(SharedMemory);
  static Atomic<bool> registered;
  if (registered.compareExchange(false, true)) {
    RegisterStrongMemoryReporter(new ShmemReporter());
  }
}

inline bool Atomic<T>::cswap ( const Atomic<T> &oldval, const Atomic<T> &newval )
{
#ifdef HAVE_NEW_GCC_ATOMIC_OPS
   // FIXME: The atomics passed are const
   T* oldv = const_cast<T*>(&oldval._value);
   T* newv = const_cast<T*>(&newval._value);
   return __atomic_compare_exchange_n( &_value, oldv, newv,
         /* weak */ false, __ATOMIC_ACQ_REL, __ATOMIC_ACQUIRE );
#else
   return __sync_bool_compare_and_swap ( &_value, oldval.value(), newval.value() );
#endif
}

void Census::visit(const std::shared_ptr<Instruction> &instruction) {
	instructions_.push_back(instruction.get());
	unique_ = false;

	switch (instruction->mnemonic()) {
		case Instruction::READ: {
			Read *read = instruction->as<Read>();
			visit(read->reg());
			visit(read->address());
			spaces_.push_back(read->space());
			break;
		}
		case Instruction::WRITE: {
			Write *write = instruction->as<Write>();
			visit(write->value());
			visit(write->address());
			spaces_.push_back(write->space());
			break;
		}
		case Instruction::MFENCE: {
			break;
		}
		case Instruction::LOCAL: {
			Local *local = instruction->as<Local>();
			visit(local->reg());
			visit(local->value());
			break;
		}
		case Instruction::CONDITION: {
			Condition *condition = instruction->as<Condition>();
			visit(condition->expression());
			break;
		}
		case Instruction::ATOMIC: {
			Atomic *atomic = instruction->as<Atomic>();
			for (const auto &instr : atomic->instructions()) {
				visit(instr);
			}
			break;
		}
		case Instruction::NOOP: /* FALLTHROUGH */
		case Instruction::LOCK: /* FALLTHROUGH */
		case Instruction::UNLOCK:
			break;
		default: {
			assert(!"NEVER REACHED");
		}
	}
}

double testPerfAddAndFetch()
{
    const std::size_t iters(30000);
    StopWatch stopWatch;
    double total(0);

    for(std::size_t iter = 0; iter != iters; ++iter)
    {
        Atomic<T> atomic;
        stopWatch.start();
        for(std::size_t count = 0; count != testing::STANDARD_SPEED_COUNT; ++count) {
            atomic.addAndFetch(1);
        }
        stopWatch.stop();
        total += getTimevalAsMicros(stopWatch.elapsed());
        stopWatch.reset();
    }
    return testing::calcNanosPer(total, iters);
}

double testPerfFetch()
{
    const std::size_t iters(30000);
    StopWatch stopWatch;
    double total(0);

    int foo(0);
    for(std::size_t iter = 0; iter != iters; ++iter)
    {
        Atomic<T> atomic;
        stopWatch.start();
        for(std::size_t count = 0; count != testing::STANDARD_SPEED_COUNT; ++count) {
            foo += atomic.fetch(); // To ensure fetch is actually called
        }
        stopWatch.stop();
        total += getTimevalAsMicros(stopWatch.elapsed());
        stopWatch.reset();
    }
    return testing::calcNanosPer(total, iters);
}

double testPerfCompareAndSwap(bool success)
{
    const std::size_t iters(30000);
    StopWatch stopWatch;
    double total(0);
    const T compare = success ? 0 : 1;

    for(std::size_t iter = 0; iter != iters; ++iter)
    {
        Atomic<T> atomic;
        stopWatch.start();
        for(std::size_t count = 0; count != testing::STANDARD_SPEED_COUNT; ++count) {
            atomic.compareAndSwap(compare, compare);
        }
        stopWatch.stop();
        total += getTimevalAsMicros(stopWatch.elapsed());
        stopWatch.reset();
    }
    return testing::calcNanosPer(total, iters);
}

//.........这里部分代码省略.........
                if( importData->prelights )
                {
                    geometry->getPrelights(0)[i] = wrap( importData->prelights[i] );
                }
            }
            for( i=0; i<importData->numTriangles; i++ )
            {
                /*
                geometry->getTriangles()[i].set(
                    importData->triangles[i].vertexId[0],
					importData->triangles[i].vertexId[2],
					importData->triangles[i].vertexId[1],					
                    importData->triangles[i].materialId
                );
                */
                geometry->getTriangles()[i].set(
                    importData->triangles[i].vertexId[0],
                    importData->triangles[i].vertexId[1],
					importData->triangles[i].vertexId[2],					
                    importData->triangles[i].materialId
                );
            }
            for( i=0; i<importData->numMaterials; i++ )
            {
                ShaderI shaderI = _shaders.find( importData->materials[i] );
                assert( shaderI != _shaders.end() );
                geometry->setShader( i, shaderI->second );
            }
            geometry->instance();
            _geometries.insert( GeometryT( importData->id, geometry ) );
            iImport->release( importData );
        }
        break;
    case import::itAtomic:
        {
            import::ImportAtomic* importData = iImportStream->importAtomic();
            Atomic* atomic = new Atomic;
            FrameI frameI = _frames.find( importData->frameId );
            assert( frameI != _frames.end() );
            atomic->setFrame( frameI->second );
            GeometryI geometryI = _geometries.find( importData->geometryId );
            assert( geometryI != _geometries.end() );
            atomic->setGeometry( geometryI->second );            
            TextureI textureI = _textures.find( importData->lightmapId );
            if( textureI != _textures.end() ) 
            {
                atomic->setLightMap( textureI->second );
            }
            _atomics.insert( AtomicT( importData->id, atomic ) );
            iImport->release( importData );
        }
        break;
    case import::itClump:
        {
            import::ImportClump* importData = iImportStream->importClump();
            Clump* clump = new Clump( importData->name );
            FrameI frameI = _frames.find( importData->frameId );
            assert( frameI != _frames.end() );
            clump->setFrame( frameI->second );
            frameI->second->dirty();
            for( int i=0; i<importData->numAtomics; i++ )
            {
                AtomicI atomicI = _atomics.find( importData->atomics[i] );
                assert( atomicI != _atomics.end() );
                clump->add( atomicI->second );
            }

void
Triangle_Processor::Process( Stack<AtomicRegion>&  Offspring)
  {
  TimesCalled ++;
  if (TimesCalled == 1)
    {
    TheRule->Apply(LocalIntegrand(),Geometry(),Integral(),AbsoluteError());
    Offspring.MakeEmpty();
    return;
    };
  if(TimesCalled == 2)
    {
    real NewVolume
          = Geometry().Volume()/2;
    Stack<Triangle> Parts;
    Vector<unsigned int> DiffOrder(Diffs.Size());
    const real difffac = real(1)/real(0.45);    
    const real difftreshold = 1e-3;

    TheRule->ComputeDiffs(LocalIntegrand(),Geometry(),Diffs); 

    // Sort the differences in descending order.
    for (unsigned int ik=0 ; ik<=2 ; ik++)  { DiffOrder[ik] = ik; }
    for (unsigned int i=0 ; i<=1 ; i++)  
      {
     for (unsigned int k=i+1 ; k<=2 ; k++)
         if (Diffs[DiffOrder[k]]>Diffs[DiffOrder[i]])
            {
            unsigned int h = DiffOrder[i];
            DiffOrder[i] = DiffOrder[k];
            DiffOrder[k] = h;
            }
      }

    if (Diffs[DiffOrder[0]] < difftreshold)
      {
      TheDivisor4->Apply(Geometry(),Parts,DiffOrder);
      NewVolume /=2;
      }
    else 
      {
      if (Diffs[DiffOrder[0]]>difffac*Diffs[DiffOrder[2]])
        {
        TheDivisor2->Apply (Geometry(),Parts,DiffOrder);
        }
      else 
        { 
        TheDivisor4->Apply(Geometry(),Parts,DiffOrder);
        NewVolume /=2;
        }	
      };

    unsigned int N = Parts.Size();
    for (unsigned int ii =0;ii<N;ii++)
      {
      Triangle* g = Parts.Pop();
      g->Volume(NewVolume);
      Processor<Triangle>* p = Descendant();
      Atomic<Triangle>* a = new Atomic<Triangle>(g,p);
      a->LocalIntegrand(&LocalIntegrand());
      Offspring.Push(a);
      };
    return;
    };
   Error(TimesCalled > 2,
     "Triangle_Processor : more than two calls of Process()");
   }

//==============================================================================
ANKI_TEST(Resource, AsyncLoader)
{
	HeapAllocator<U8> alloc(allocAligned, nullptr);

	// Simple create destroy
	{
		AsyncLoader a;
		a.init(alloc);
	}

	// Simple task that will finish
	{
		AsyncLoader a;
		a.init(alloc);
		Barrier barrier(2);

		a.submitNewTask<Task>(0.0, &barrier, nullptr);
		barrier.wait();
	}

	// Many tasks that will finish
	{
		AsyncLoader a;
		a.init(alloc);
		Barrier barrier(2);
		Atomic<U32> counter = {0};
		const U COUNT = 100;

		for(U i = 0; i < COUNT; i++)
		{
			Barrier* pbarrier = nullptr;

			if(i == COUNT - 1)
			{
				pbarrier = &barrier;
			}

			a.submitNewTask<Task>(0.01, pbarrier, &counter);
		}

		barrier.wait();

		ANKI_TEST_EXPECT_EQ(counter.load(), COUNT);
	}

	// Many tasks that will _not_ finish
	{
		AsyncLoader a;
		a.init(alloc);

		for(U i = 0; i < 100; i++)
		{
			a.submitNewTask<Task>(0.0, nullptr, nullptr);
		}
	}

	// Tasks that allocate
	{
		AsyncLoader a;
		a.init(alloc);
		Barrier barrier(2);

		for(U i = 0; i < 10; i++)
		{
			Barrier* pbarrier = nullptr;

			if(i == 9)
			{
				pbarrier = &barrier;
			}

			a.submitNewTask<MemTask>(alloc, pbarrier);
		}

		barrier.wait();
	}

	// Tasks that allocate and never finished
	{
		AsyncLoader a;
		a.init(alloc);

		for(U i = 0; i < 10; i++)
		{
			a.submitNewTask<MemTask>(alloc, nullptr);
		}
	}

	// Pause/resume
	{
		AsyncLoader a;
		a.init(alloc);
		Atomic<U32> counter(0);
		Barrier barrier(2);

		// Check if the pause will sync
		a.submitNewTask<Task>(0.5, nullptr, &counter, 0);
		HighRezTimer::sleep(0.25); // Wait for the thread to pick the task...
		a.pause(); /// ...and then sync
//.........这里部分代码省略.........