Ejemplo n.º 1
0
 /**
  * Copies this data and the RingBuffer data from host to device.
  */
 void hostToDevice()
 {
     __startTransaction(__getTransactionEvent());
     ringBuffer->hostToDevice();
     EventTask ev1 = __endTransaction();
     __startTransaction(__getTransactionEvent());
     GridBuffer<VALUE, DIM1, BORDERVALUE>::hostToDevice();
     __setTransactionEvent(__endTransaction() + ev1);
 }
Ejemplo n.º 2
0
 /**
  * Copies data and additional pointers from host to device.
  */
 void hostToDevice()
 {
     __startTransaction(__getTransactionEvent());
     ringDataSizes->hostToDevice();
     EventTask ev1 = __endTransaction();
     __startTransaction(__getTransactionEvent());
     ringData->hostToDevice();
     __setTransactionEvent(__endTransaction() + ev1);
 }
Ejemplo n.º 3
0
 /**
  * Copies data and additional pointers from device to host.
  */
 void deviceToHost()
 {
     __startTransaction(__getTransactionEvent());
     ringDataSizes->deviceToHost();
     EventTask ev1 = __endTransaction();
     __startTransaction(__getTransactionEvent());
     ringData->deviceToHost();
     __setTransactionEvent(__endTransaction() + ev1);
 }
Ejemplo n.º 4
0
    /**
     * Copies this data and the RingBuffer data from device to host.
     */
    void deviceToHost()
    {
        __startTransaction(__getTransactionEvent());
        ringBuffer->deviceToHost();
        EventTask ev1 = __endTransaction();

        __startTransaction(__getTransactionEvent());
        GridBuffer<VALUE, DIM1, BORDERVALUE>::deviceToHost();
        EventTask ev2 = __endTransaction();

        __setTransactionEvent(ev1 + ev2);
    }
Ejemplo n.º 5
0
 virtual void init()
 {
     m_state = Init;
     __startTransaction(m_initDependency);
     m_buffer.bashField(m_exchange);
     m_initDependency = __endTransaction();
     m_state = WaitForBash;
 }
Ejemplo n.º 6
0
    /**
     * Resets all internal buffers.
     */
    void reset()
    {
        __startTransaction(__getTransactionEvent());
        frames->reset(false);
        frames->initialFillBuffer();
        EventTask ev1 = __endTransaction();
        __startTransaction(__getTransactionEvent());
        superCells->getDeviceBuffer().setValue(SuperCell<vint_t > ());
        superCells->getHostBuffer().setValue(SuperCell<vint_t > ());

        /*nextFrames->getDeviceBuffer().setValue(INV_IDX);//!\todo: is this needed? On device we set any new frame values to INVALID_INDEX
        prevFrames->getDeviceBuffer().setValue(INV_IDX);//!\todo: is this needed? On device we set any new frame values to INVALID_INDEX
        nextFrames->getHostBuffer().setValue(INV_IDX);//!\todo: is this needed? On device we set any new frame values to INVALID_INDEX
        prevFrames->getHostBuffer().setValue(INV_IDX);//!\todo: is this needed? On device we set any new frame values to INVALID_INDEX
         */
        __setTransactionEvent(__endTransaction() + ev1);
    }
 virtual void init()
 {
     state = Init;
     __startTransaction(initDependency);
     buffer.bashField(exchange);
     initDependency = __endTransaction();
     state = WaitForBash;
 }
Ejemplo n.º 8
0
    void setCurrentSize(const size_t size)
    {
        // do host and device setCurrentSize parallel
        EventTask split = __getTransactionEvent();
        __startTransaction(split);
        stackIndexer.getHostBuffer().setCurrentSize(size);
        stack.getHostBuffer().setCurrentSize(size);
        EventTask e1 = __endTransaction();

        __startTransaction(split);
        stackIndexer.getDeviceBuffer().setCurrentSize(size);
        EventTask e2 = __endTransaction();
        __startTransaction(split);
        stack.getDeviceBuffer().setCurrentSize(size);
        EventTask e3 = __endTransaction();

        __setTransactionEvent(e1 + e2 + e3);
    }
Ejemplo n.º 9
0
 virtual void init()
 {
     __startTransaction();
     this->request = Environment<DIM>::get().EnvironmentController()
             .getCommunicator().startSend(
                                          exchange->getExchangeType(),
                                          (char*) exchange->getHostBuffer().getPointer(),
                                          exchange->getHostBuffer().getCurrentSize() * sizeof (TYPE),
                                          exchange->getCommunicationTag());
     __endTransaction();
 }
Ejemplo n.º 10
0
    /**
     * Starts copying data from device to host.
     */
    void deviceToHost()
    {

        __startTransaction(__getTransactionEvent());
        frames->deviceToHost();
        EventTask ev1 = __endTransaction();

        __startTransaction(__getTransactionEvent());
        superCells->deviceToHost();
        EventTask ev2 = __endTransaction();

        __startTransaction(__getTransactionEvent());
        nextFrames->deviceToHost();
        EventTask ev3 = __endTransaction();

        __startTransaction(__getTransactionEvent());
        prevFrames->deviceToHost();
        EventTask ev4 = __endTransaction();

        __setTransactionEvent(ev1 + ev2 + ev3 + ev4);
    }
        bool executeIntern()
        {
            switch (state)
            {
                case Init:
                    break;
                case WaitForReceive:

                    if (NULL == Environment<>::get().Manager().getITaskIfNotFinished(lastReceiveEvent.getTaskId()))
                    {
                        state = InitInsert;
                        //bash is finished
                        __startTransaction();
                        lastSize = parBase.getParticlesBuffer().getReceiveExchangeStack(exchange).getHostParticlesCurrentSize();
                        parBase.insertParticles(exchange);
                       // std::cout<<"brecv = "<<parBase.getParticlesBuffer().getReceiveExchangeStack(exchange).getHostCurrentSize()<<std::endl;
                        tmpEvent = __endTransaction();
                        state = WaitForInsert;
                    }

                    break;
                case InitInsert:
                    break;
                case WaitForInsert:
                    if (NULL == Environment<>::get().Manager().getITaskIfNotFinished(tmpEvent.getTaskId()))
                    {
                        state=Wait;
                        assert(lastSize <= maxSize);
                        //check for next bash round
                        if (lastSize == maxSize)
                        {
                            std::cerr << "recv max size " << maxSize << " particles" << std::endl;
                            init(); //call init and run a full send cycle

                        }
                        else
                        {
                            state = Finished;
                            return true;
                        }
                    }
                    break;
                case Wait:
                    break;
                case Finished:
                    return true;
                default:
                    return false;
            }

            return false;
        }
Ejemplo n.º 12
0
    void shiftParticles()
    {
        StrideMapping<AREA, DIM3, MappingDesc> mapper(this->cellDescription);
        ParticlesBoxType pBox = particlesBuffer->getDeviceParticleBox();

        __startTransaction(__getTransactionEvent());
        do
        {
            __cudaKernel(kernelShiftParticles)
                (mapper.getGridDim(), TileSize)
                (pBox, mapper);
        }
        while (mapper.next());

        __setTransactionEvent(__endTransaction());

    }
Ejemplo n.º 13
0
    HINLINE void operator()(
                            T_StorageTuple& tuple,
                            const uint32_t currentStep,
                            const T_Event eventInt,
                            T_Event& updateEvent,
                            T_Event& commEvent
                            ) const
    {
        typedef typename HasFlag<FrameType, particlePusher<> >::type hasPusher;
        if (hasPusher::value)
        {
            PMACC_AUTO(speciesPtr, tuple[SpeciesName()]);

            __startTransaction(eventInt);
            speciesPtr->update(currentStep);
            commEvent += speciesPtr->asyncCommunication(__getTransactionEvent());
            updateEvent += __endTransaction();
        }
    }
Ejemplo n.º 14
0
        bool executeIntern()
        {
            switch (state)
            {
                case InitDone:
                    break;
                case DeviceToHostFinished:
                    state = SendDone;
                    __startTransaction();
                    Environment<>::get().Factory().createTaskSendMPI(exchange, this);
                    __endTransaction(); //we need no blocking because we get a singnal if transaction is finished
                    break;
                case SendDone:
                    break;
                case Finish:
                    return true;
                default:
                    return false;
            }

            return false;
        }
Ejemplo n.º 15
0
 virtual void init()
 {
     __startTransaction();
     state = InitDone;
     if (exchange->hasDeviceDoubleBuffer())
     {
         Environment<>::get().Factory().createTaskCopyDeviceToDevice(exchange->getDeviceBuffer(),
                                                                        exchange->getDeviceDoubleBuffer()
                                                                        );
         copyEvent = Environment<>::get().Factory().createTaskCopyDeviceToHost(exchange->getDeviceDoubleBuffer(),
                                                                                  exchange->getHostBuffer(),
                                                                                  this);
     }
     else
     {
         copyEvent = Environment<>::get().Factory().createTaskCopyDeviceToHost(exchange->getDeviceBuffer(),
                                                                                  exchange->getHostBuffer(),
                                                                                  this);
     }
     __endTransaction(); //we need no blocking because we get a singnal if transaction is finished
     
 }
Ejemplo n.º 16
0
        bool executeIntern()
        {
            switch (state)
            {
                case WaitForReceived:
                    break;
                case RunCopy:
                    state = WaitForFinish;
                   __startTransaction();
                    exchange->getHostBuffer().setCurrentSize(newBufferSize);
                    if (exchange->hasDeviceDoubleBuffer())
                    {

                        Environment<>::get().Factory().createTaskCopyHostToDevice(exchange->getHostBuffer(),
                                                                                     exchange->getDeviceDoubleBuffer());
                        Environment<>::get().Factory().createTaskCopyDeviceToDevice(exchange->getDeviceDoubleBuffer(),
                                                                                       exchange->getDeviceBuffer(),
                                                                                       this);
                    }
                    else
                    {

                        Environment<>::get().Factory().createTaskCopyHostToDevice(exchange->getHostBuffer(),
                                                                                     exchange->getDeviceBuffer(),
                                                                                     this);
                    }
                    __endTransaction();
                    break;
                case WaitForFinish:
                    break;
                case Finish:
                    return true;
                default:
                    return false;
            }

            return false;
        }
Ejemplo n.º 17
0
 void event(id_t, EventType type, IEventData* data)
 {
     switch (type)
     {
         case RECVFINISHED:
             if (data != NULL)
             {
                 __startTransaction(); //no blocking
                 EventDataReceive *rdata = static_cast<EventDataReceive*> (data);
                 // std::cout<<" data rec "<<rdata->getReceivedCount()/sizeof(TYPE)<<std::endl;
                 newBufferSize = rdata->getReceivedCount() / sizeof (TYPE);
                 __endTransaction();
                 state = RunCopy;
                 executeIntern();
             }
             break;
         case COPYHOST2DEVICE:
         case COPYDEVICE2DEVICE:
             state = Finish;
             break;
         default:
             return;
     }
 }