Method Compute

en_ops/e_clip.cc:107–148

        OP_REQUIRES(context, lib != NULL, errors::Unknown("Unable to load sgx.so!"));
    }
    void Compute(OpKernelContext *context) override
    {

        const Tensor &grad = context->input(0);
        const Tensor &input = context->input(1);

        const Tensor &down = context->input(2);
        auto down_flat = down.flat<float>();

        const Tensor &up = context->input(3);
        auto up_flat = up.flat<float>();

        auto grad_flat = grad.flat<float>();
        auto input_flat = input.flat<float>();

        const TensorShape &input_shape = input.shape();

        Tensor *output = NULL;
        OP_REQUIRES_OK(context, context->allocate_output(0, input_shape, &output));
        auto output_flat = output->flat<float>();

        int N = input_flat.size() / times_;

        int n1 = 1;
        int n2 = 1;
        if (down_flat.size() > 1)
        {
            n1 = down_flat.size() / times_;
        }
        if (up_flat.size() > 1)
        {
            n2 = up_flat.size() / times_;
        }

        unsigned long int eid_ = (eid_high_ << 32) + eid_low_;
        typedef void (*function)(unsigned long int eid, float *input, float *grad, float *down, float *up, int n1, int n2, int N, float *output);
        dlerror();
        function clip_grad_kernel = (function)dlsym(lib, "clip_grad");
        const char *dlsym_error = dlerror();
        OP_REQUIRES(context, !dlsym_error, errors::Unknown("loading of clip_grad failed: ", dlsym_error));
        clip_grad_kernel(eid_, (float *)input_flat.data(), (float *)grad_flat.data(), (float *)down_flat.data(), (float *)up_flat.data(), n1, n2, N, (float *)output_flat.data());
    };

private:
    void *lib;