how to add a function(which can be called by EmitterPtr on GPU) into class Emitter

[GensokyoLover]

This is my function to be added into Emitter

  void put(const Point2f &pos, const Float *values, Mask active = true) const {
    m_block->put(pos,values,active);
   }
  mutable ref<ImageBlock<Float,Spectrum>> m_block;

it succeeded when i use Emitter*,but failed when EmitterPtr. I know EmitterPtr is an array and have tried much to know how it works,but still falls. i want to add it for calculating the contribution of each light source when rendering. thanks

[njroussel]

Hi @GensokyoLover

You need add a new macro in emitter.h. Every single just-in-time compiled vcall must be declared with DRJIT_VCALL_METHOD(new_function).

[GensokyoLover]

Really Really Really thanks for your reply，and this problem i had noticed and added it in my project but still failed. Below is a more detailed description of my problem

reports

         2023-04-03 16:55:28 INFO  main  [SamplingIntegrator] Computation graph recorded. (took 7.884s)
  jit_optix_log(): [COMPILE FEEDBACK] COMPILE ERROR: Invalid PTX input: ptx2llvm-module-001: error: Failed to parse input PTX string
  ptx2llvm-module-001, line 1871; error   : Arguments mismatch for instruction 'ld'
  ptx2llvm-module-001, line 1872; error   : Arguments mismatch for instruction 'ld'
  ptx2llvm-module-001, line 1873; error   : Arguments mismatch for instruction 'ld'
  ptx2llvm-module-001, line 1874; error   : Arguments mismatch for instruction 'ld'
  ptx2llvm-module-001, line 1875; error   : Arguments mismatch for instruction 'ld'
  ptx2llvm-module-001, line 1876; error   : Arguments mismatch for instruction 'ld'
  ptx2llvm-module-001, line 1877; error   : Arguments mismatch for instruction 'ld'
  ptx2llvm-module-001, line 1888; error   : Arguments mismatch for instruction 'mov'
  ptx2llvm-module-001, line 1889; error   : Arguments mismatch for instruction 'mov'
  ptx2llvm-module-001, line 1890; error   : Arguments mismatch for instruction 'mov'
  ptx2llvm-module-001, line 1891; error   : Arguments mismatch for instruction 'mov'
  ptx2llvm-module-001, line 1892; error   : Arguments mismatch for instruction 'mov'
  ptx2llvm-module-001, line 1893; error   : Arguments mismatch for instruction 'mov'
  ptx2llvm-module-001, line 1894; error   : Arguments mismatch for instruction 'mov'
  ptx2llvm-module-001, line 1871; error   : Unknown symbol '%f574'
  ptx2llvm-module-001, line 1872; error   : Unknown symbol '%f573'
  ptx2llvm-module-001, line 1873; error   : Unknown symbol '%f572'
  ptx2llvm-module-001, line 1874; error   : Unknown symbol '%f586'
  ptx2llvm-module-001, line 1875; error   : Unknown symbol '%f575'
  ptx2llvm-module-001, line 1876; error   : Unknown symbol '%f576'
  ptx2llvm-module-001, line 1877; error   : Unknown symbol '%f577'
  ptx2llvm-module-001, line 1888; error   : Unknown symbol '%f574'
  ptx2llvm-module-001, line 1889; error   : Unknown symbol '%f573'
  ptx2llvm-module-001, line 1890; error   : Unknown symbol '%f572'
  ptx2llvm-module-001, line 1891; error   : Unknown symbol '%f586'
  ptx2llvm-module-001, line 1892; error   : Unknown symbol '%f575'
  ptx2llvm-module-001, line 1893; error   : Unknown symbol '%f576'
  ptx2llvm-module-001, line 1894; error   : Unknown symbol '%f577'
  Cannot parse input PTX string
  
  
  
  Critical Dr.Jit compiler failure: jit_optix_compile(): optixModuleGetCompilationState() indicates that the compilation did not complete succesfully. The module's compilation state is: 0x2363
  Please see the PTX assembly listing and error message below:
  
  .version 6.3
  .target sm_75
  .address_size 64
          .....

method

 cuda_rgb

function and varible added in Class Emitter

 void put(const Point2f &pos, const Float *values,
         Mask active= true) const {
    //MI_MASKED_FUNCTION(ProfilerPhase::EmitPut, active)
    m_block->put(pos, values);
}
  mutable ref<ImageBlock<Float,Spectrum>> m_block;
   DRJIT_VCALL_METHOD(put)

used in path.cpp PathIntegrator::sample

   std::pair<Spectrum, Bool>
sample(const Vector2f& pos_,Scene *scene,
                                 Sampler *sampler,
                                 const RayDifferential3f &ray_,
                                 const Medium * /* medium */,
                                 Float * aov,
                                 Bool active) const override {
    MI_MASKED_FUNCTION(ProfilerPhase::SamplingIntegratorSample, active);

    if (unlikely(m_max_depth == 0))
        return { 0.f, false };

    // --------------------- Configure loop state ----------------------

    Ray3f ray                     = Ray3f(ray_);
    Vector2f pos                  = Vector2f(pos_);
    Spectrum throughput           = 1.f;
    Spectrum result               = 0.f;
    Float eta                     = 1.f;
    UInt32 depth                  = 0;

    // If m_hide_emitters == false, the environment emitter will be visible
    Mask valid_ray                = !m_hide_emitters && dr::neq(scene->environment(), nullptr);

    // Variables caching information from the previous bounce
    Interaction3f prev_si         = dr::zeros<Interaction3f>();
    Float         prev_bsdf_pdf   = 1.f;
    Bool          prev_bsdf_delta = true;
    BSDFContext   bsdf_ctx;

    /* Set up a Dr.Jit loop. This optimizes away to a normal loop in scalar
       mode, and it generates either a a megakernel (default) or
       wavefront-style renderer in JIT variants. This can be controlled by
       passing the '-W' command line flag to the mitsuba binary or
       enabling/disabling the JitFlag.LoopRecord bit in Dr.Jit.

       The first argument identifies the loop by name, which is helpful for
       debugging. The subsequent list registers all variables that encode
       the loop state variables. This is crucial: omitting a variable may
       lead to undefined behavior. */
    dr::Loop<Bool> loop("Path Tracer", sampler, pos,ray, throughput, result,
                        eta, depth, valid_ray, prev_si, prev_bsdf_pdf,
                        prev_bsdf_delta, active);

    /* Inform the loop about the maximum number of loop iterations.
       This accelerates wavefront-style rendering by avoiding costly
       synchronization points that check the 'active' flag. */
    loop.set_max_iterations(m_max_depth);
    Film *film = (scene->sensors()[0]->film());
    while (loop(active)) {
        /* dr::Loop implicitly masks all code in the loop using the 'active'
           flag, so there is no need to pass it to every function */

        SurfaceInteraction3f si =
            scene->ray_intersect(ray,
                                 /* ray_flags = */ +RayFlags::All,
                                 /* coherent = */ dr::eq(depth, 0u));

        // ---------------------- Direct emission ----------------------

        /* dr::any_or() checks for active entries in the provided boolean
           array. JIT/Megakernel modes can't do this test efficiently as
           each Monte Carlo sample runs independently. In this case,
           dr::any_or<..>() returns the template argument (true) which means
           that the 'if' statement is always conservatively taken. */
        if (dr::any_or<true>(dr::neq(si.emitter(scene), nullptr))) {
            DirectionSample3f ds(scene, si, prev_si);
            Float em_pdf = 0.f;
            Mask emit_active = dr::neq(si.emitter(scene), nullptr);
            if (dr::any_or<true>(!prev_bsdf_delta))
                em_pdf = scene->pdf_emitter_direction(prev_si, ds,
                                                      !prev_bsdf_delta);

            // Compute MIS weight for emitter sample from previous bounce
            Float mis_bsdf = mis_weight(prev_bsdf_pdf, em_pdf);
            
            // Accumulate, being careful with polarization (see spec_fma)
            Spectrum this_result = result;
            result = spec_fma(
                throughput,
                ds.emitter->eval(si, prev_bsdf_pdf > 0.f) * mis_bsdf,
                result);
            this_result          = result - this_result;
            EmitterPtr emitptr  = si.emitter(scene);

            
            Color3f rgb;
            rgb = this_result;
            std::cout << typeid(emitptr).name() << std::endl;
            aov[0] = rgb.x();
            aov[1] = rgb.y();
            aov[2] = rgb.z();
            aov[3] = rgb.x();
            emitptr->put(pos, aov);

        }

        // Continue tracing the path at this point?
        Bool active_next = (depth + 1 < m_max_depth) && si.is_valid();

        if (dr::none_or<false>(active_next))
            break; // early exit for scalar mode

        BSDFPtr bsdf = si.bsdf(ray);

        // ---------------------- Emitter sampling ----------------------

        // Perform emitter sampling?
        Mask active_em = active_next && has_flag(bsdf->flags(), BSDFFlags::Smooth);

        DirectionSample3f ds = dr::zeros<DirectionSample3f>();
        Spectrum em_weight = dr::zeros<Spectrum>();
        Vector3f wo = dr::zeros<Vector3f>();
        EmitterPtr emitptr;
        if (dr::any_or<true>(active_em)) {
            // Sample the emitter
            std::tie(ds, em_weight) = scene->sample_emitter_direction(
                si, sampler->next_2d(), true, active_em);
            active_em &= dr::neq(ds.pdf, 0.f);

            /* Given the detached emitter sample, recompute its contribution
               with AD to enable light source optimization. */
            if (dr::grad_enabled(si.p)) {
                ds.d = dr::normalize(ds.p - si.p);
                Spectrum em_val = scene->eval_emitter_direction(si, ds, active_em);
                em_weight = dr::select(dr::neq(ds.pdf, 0), em_val / ds.pdf, 0);
            }
            emitptr = ds.emitter;
            wo = si.to_local(ds.d);
        }

        // ------ Evaluate BSDF * cos(theta) and sample direction -------

        Float sample_1 = sampler->next_1d();
        Point2f sample_2 = sampler->next_2d();

        auto [bsdf_val, bsdf_pdf, bsdf_sample, bsdf_weight]
            = bsdf->eval_pdf_sample(bsdf_ctx, si, wo, sample_1, sample_2);

        // --------------- Emitter sampling contribution ----------------

        if (dr::any_or<true>(active_em)) {
            bsdf_val = si.to_world_mueller(bsdf_val, -wo, si.wi);

            // Compute the MIS weight
            Float mis_em =
                dr::select(ds.delta, 1.f, mis_weight(ds.pdf, bsdf_pdf));

            // Accumulate, being careful with polarization (see spec_fma)
            Spectrum this_result = result;
            result[active_em] = spec_fma(
                throughput, bsdf_val * em_weight * mis_em, result);
            this_result        = result - this_result;
            Color3f rgb;
            rgb = this_result;
            std::cout << typeid(emitptr).name() << std::endl;
            aov[0] = rgb.x();
            aov[1] = rgb.y();
            aov[2] = rgb.z();
            aov[3] = rgb.x();
            emitptr->put(pos, aov);
        }

        // ---------------------- BSDF sampling ----------------------

        bsdf_weight = si.to_world_mueller(bsdf_weight, -bsdf_sample.wo, si.wi);

        ray = si.spawn_ray(si.to_world(bsdf_sample.wo));

        /* When the path tracer is differentiated, we must be careful that
           the generated Monte Carlo samples are detached (i.e. don't track
           derivatives) to avoid bias resulting from the combination of moving
           samples and discontinuous visibility. We need to re-evaluate the
           BSDF differentiably with the detached sample in that case. */
        if (dr::grad_enabled(ray)) {
            ray = dr::detach<true>(ray);

            // Recompute 'wo' to propagate derivatives to cosine term
            Vector3f wo_2 = si.to_local(ray.d);
            auto [bsdf_val_2, bsdf_pdf_2] = bsdf->eval_pdf(bsdf_ctx, si, wo_2, active);
            bsdf_weight[bsdf_pdf_2 > 0.f] = bsdf_val_2 / dr::detach(bsdf_pdf_2);
        }

        // ------ Update loop variables based on current interaction ------

        throughput *= bsdf_weight;
        eta *= bsdf_sample.eta;
        valid_ray |= active && si.is_valid() &&
                     !has_flag(bsdf_sample.sampled_type, BSDFFlags::Null);

        // Information about the current vertex needed by the next iteration
        prev_si = si;
        prev_bsdf_pdf = bsdf_sample.pdf;
        prev_bsdf_delta = has_flag(bsdf_sample.sampled_type, BSDFFlags::Delta);

        // -------------------- Stopping criterion ---------------------

        dr::masked(depth, si.is_valid()) += 1;

        Float throughput_max = dr::max(unpolarized_spectrum(throughput));

        Float rr_prob = dr::minimum(throughput_max * dr::sqr(eta), .95f);
        Mask rr_active = depth >= m_rr_depth,
             rr_continue = sampler->next_1d() < rr_prob;

        /* Differentiable variants of the renderer require the the russian
           roulette sampling weight to be detached to avoid bias. This is a
           no-op in non-differentiable variants. */
        throughput[rr_active] *= dr::rcp(dr::detach(rr_prob));

        active = active_next && (!rr_active || rr_continue) &&
                 dr::neq(throughput_max, 0.f);
    }

    return {
        /* spec  = */ dr::select(valid_ray, result, 0.f),
        /* valid = */ valid_ray
    };
}

[njroussel]

The DRJIT_VCALL_METHOD(put) line must be in the emitter.h file next to the other ones: here. It has to be between the DRJIT_VCALL_TEMPLATE_BEGIN and DRJIT_VCALL_TEMPLATE_END macros.

Are you already doing this?

[GensokyoLover]

Yes, i did so,but it still can not work
DRJIT_VCALL_TEMPLATE_BEGIN(mitsuba::Emitter)
DRJIT_VCALL_METHOD(sample_ray)
DRJIT_VCALL_METHOD(sample_direction)
DRJIT_VCALL_METHOD(pdf_direction)
DRJIT_VCALL_METHOD(eval_direction)
DRJIT_VCALL_METHOD(sample_position)
DRJIT_VCALL_METHOD(pdf_position)
DRJIT_VCALL_METHOD(eval)
DRJIT_VCALL_METHOD(sample_wavelengths)
DRJIT_VCALL_METHOD(is_environment)
DRJIT_VCALL_METHOD(put)
DRJIT_VCALL_GETTER(flags, uint32_t)
DRJIT_VCALL_GETTER(shape, const typename Class::Shape *)
DRJIT_VCALL_GETTER(medium, const typename Class::Medium *)
DRJIT_VCALL_TEMPLATE_END(mitsuba::Emitter)

[njroussel]

Humm weird. Please file an issue if you can create a small reproducer.

I'll mark this discussion as answered since the original question was about that.

[GensokyoLover]

OK,I have filed