from caffe2.python import timeout_guard

def fun_conclude_operator(self):
    # Ensure the program exists. This is to "fix" some unknown problems
    # causing the job sometimes get stuck.
    timeout_guard.EuthanizeIfNecessary(600.0)



            

Reported by Pylint.

              




from caffe2.python import timeout_guard

def fun_conclude_operator(self):
    # Ensure the program exists. This is to "fix" some unknown problems

            

Reported by Pylint.

              
from caffe2.python import timeout_guard

def fun_conclude_operator(self):
    # Ensure the program exists. This is to "fix" some unknown problems
    # causing the job sometimes get stuck.
    timeout_guard.EuthanizeIfNecessary(600.0)



            

Reported by Pylint.

                  timeout_guard.EuthanizeIfNecessary(600.0)


def assembleAllOutputs(self):
    output = {}
    output['train_model'] = self.train_model
    output['test_model'] = self.test_model
    output['model'] = self.model_output
    output['metrics'] = self.metrics_output

            

Reported by Pylint.

                  timeout_guard.EuthanizeIfNecessary(600.0)


def assembleAllOutputs(self):
    output = {}
    output['train_model'] = self.train_model
    output['test_model'] = self.test_model
    output['model'] = self.model_output
    output['metrics'] = self.metrics_output

            

Reported by Pylint.

              
    void store(void* ptr, int count = size()) const {
      if (count != size()) {
        memcpy(ptr, &vals, count * sizeof(value_type));
      } else {
        _mm512_storeu_si512((__m512i*)ptr, vals);
      }
    }


            

Reported by FlawFinder.

              
    void store(void* ptr, int count = size()) const {
        if (count != size()) {
            memcpy(ptr, &vals, count * sizeof(value_type));
        } else {
            _mm512_storeu_si512((__m512i*)ptr, vals);
        }
    }


            

Reported by FlawFinder.

              
    void store(void* ptr, int count = size()) const {
        if (count != size()) {
            memcpy(ptr, &vals, count * sizeof(value_type));
        } else {
            _mm512_storeu_si512((__m512i*)ptr, vals);
        }
    }


            

Reported by FlawFinder.

                }

  VectorizedQuantizedConverter(const void* ptr) {
    memcpy(vals.data(), ptr, sizeof(value_type) * size());
  }

  void store(void* ptr, int count = size()) const {
    memcpy(ptr, vals.data(), count * sizeof(value_type));
  }

            

Reported by FlawFinder.

                }

  void store(void* ptr, int count = size()) const {
    memcpy(ptr, vals.data(), count * sizeof(value_type));
  }

  float_vec_return_type dequantize(
      Vectorized<float> scale,
      Vectorized<float> zero_point,

            

Reported by FlawFinder.

                char msg[2048];
  va_list args;
  va_start(args, fmt);
  vsnprintf(msg, 2048, fmt, args);
  va_end(args);
  throw std::runtime_error(msg);
}

#if defined(_MSC_VER) && _MSC_VER <= 1900

            

Reported by FlawFinder.

              #include <stdarg.h>

static inline void barf(const char *fmt, ...) {
  char msg[2048];
  va_list args;
  va_start(args, fmt);
  vsnprintf(msg, 2048, fmt, args);
  va_end(args);
  throw std::runtime_error(msg);

            

Reported by FlawFinder.

                ASSERT(t1.allclose(t2));

// allclose broadcasts, so check same size before allclose.
#define ASSERT_ALLCLOSE_TOLERANCES(t1, t2, atol, rtol)   \
  ASSERT(t1.is_same_size(t2));    \
  ASSERT(t1.allclose(t2, atol, rtol));

            

Reported by FlawFinder.

              // allclose broadcasts, so check same size before allclose.
#define ASSERT_ALLCLOSE_TOLERANCES(t1, t2, atol, rtol)   \
  ASSERT(t1.is_same_size(t2));    \
  ASSERT(t1.allclose(t2, atol, rtol));

            

Reported by FlawFinder.

                ASSERT_THROWSM(fn, "");

#define ASSERT_EQUAL(t1, t2) \
  ASSERT(t1.equal(t2));

// allclose broadcasts, so check same size before allclose.
#define ASSERT_ALLCLOSE(t1, t2)   \
  ASSERT(t1.is_same_size(t2));    \
  ASSERT(t1.allclose(t2));

            

Reported by FlawFinder.

                      using vec = TypeParam;
        using VT = ValueType<TypeParam>;
        test_binary<vec>(
            NAME_INFO(== ),
            [](const VT& v1, const VT& v2) {return func_cmp(std::equal_to<VT>(), v1, v2); },
            [](const vec& v0, const vec& v1) { return v0 == v1; },
            createDefaultBinaryTestCase<vec>(TestSeed(), true));
    }
    TYPED_TEST(Comparison, NotEqual) {

            

Reported by Cppcheck.

                      using VT = ValueType<TypeParam>;
        constexpr size_t b_size = vec::size() * sizeof(VT);
        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers,cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)
        CACHE_ALIGN unsigned char ref_storage[128 * b_size];
        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers,cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)
        CACHE_ALIGN unsigned char storage[128 * b_size];
        auto seed = TestSeed();
        ValueGen<unsigned char> generator(seed);
        for (auto& x : ref_storage) {

            

Reported by FlawFinder.

                      // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers,cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)
        CACHE_ALIGN unsigned char ref_storage[128 * b_size];
        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers,cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)
        CACHE_ALIGN unsigned char storage[128 * b_size];
        auto seed = TestSeed();
        ValueGen<unsigned char> generator(seed);
        for (auto& x : ref_storage) {
            x = generator.get();
        }

            

Reported by FlawFinder.

                      // generate expected_val
        for (int64_t i = 0; i < vec::size(); i++) {
            int64_t hex_mask = 0;
            std::memcpy(&hex_mask, &mask[i], sizeof(VT));
            expected_val[i] = (hex_mask & 0x01) ? b[i] : a[i];
        }
        // test with blendv
        auto vec_a = vec::loadu(a);
        auto vec_b = vec::loadu(b);

            

Reported by FlawFinder.

                      }
        else {
          int64_t hex_mask = 0xFFFFFFFFFFFFFFFF;
          std::memcpy(&mask[idx], &hex_mask, sizeof(VT));
        }
        if (!test_blendv<vec, VT, idx+1, N>(expected_val, a, b, mask)) return false;
        mask[idx] = m;
        return true;
    }

            

Reported by FlawFinder.

              # each of them are waiting for different rendezvous to join, they will
# never wait for each other and therefore timeout eventually.

def gen_rendezvous_ctx(self, model, dataset, is_train):
    if self.opts['distributed']['num_shards'] < 2:
        return None
    # have issue when try to set this up on more shards
    workspace.RunOperatorOnce(
        core.CreateOperator(

            

Reported by Pylint.

              # each of them are waiting for different rendezvous to join, they will
# never wait for each other and therefore timeout eventually.

def gen_rendezvous_ctx(self, model, dataset, is_train):
    if self.opts['distributed']['num_shards'] < 2:
        return None
    # have issue when try to set this up on more shards
    workspace.RunOperatorOnce(
        core.CreateOperator(

            

Reported by Pylint.

                  workspace.RunOperatorOnce(
        core.CreateOperator(
            "FileStoreHandlerCreate", [], ["store_handler"],
            path="/tmp",
            prefix="epoch.{}".format(self.epoch),
        )
    )

    rendezvous = dict(

            

Reported by Bandit.

              




from caffe2.python import core, workspace
from caffe2.python import dyndep
dyndep.InitOpsLibrary('@/caffe2/caffe2/distributed:file_store_handler_ops')


            

Reported by Pylint.

              # each of them are waiting for different rendezvous to join, they will
# never wait for each other and therefore timeout eventually.

def gen_rendezvous_ctx(self, model, dataset, is_train):
    if self.opts['distributed']['num_shards'] < 2:
        return None
    # have issue when try to set this up on more shards
    workspace.RunOperatorOnce(
        core.CreateOperator(

            

Reported by Pylint.

              

import caffe2.python._import_c_extension as C
from caffe2.proto.caffe2_pb2 import NetDef

def fakeFp16FuseOps(net : NetDef) -> NetDef:
    net_str = net.SerializeToString()

    out_str = C.fakeFp16FuseOps(net_str)

            

Reported by Pylint.

              def fakeFp16FuseOps(net : NetDef) -> NetDef:
    net_str = net.SerializeToString()

    out_str = C.fakeFp16FuseOps(net_str)
    out_net = NetDef()
    out_net.ParseFromString(out_str)

    return out_net

            

Reported by Pylint.

              #!/usr/bin/env python3




import caffe2.python._import_c_extension as C
from caffe2.proto.caffe2_pb2 import NetDef

def fakeFp16FuseOps(net : NetDef) -> NetDef:

            

Reported by Pylint.

              import caffe2.python._import_c_extension as C
from caffe2.proto.caffe2_pb2 import NetDef

def fakeFp16FuseOps(net : NetDef) -> NetDef:
    net_str = net.SerializeToString()

    out_str = C.fakeFp16FuseOps(net_str)
    out_net = NetDef()
    out_net.ParseFromString(out_str)

            

Reported by Pylint.

              import caffe2.python._import_c_extension as C
from caffe2.proto.caffe2_pb2 import NetDef

def fakeFp16FuseOps(net : NetDef) -> NetDef:
    net_str = net.SerializeToString()

    out_str = C.fakeFp16FuseOps(net_str)
    out_net = NetDef()
    out_net.ParseFromString(out_str)

            

Reported by Pylint.

                const void* src_ptr = static_cast<const void*>(onnx_tensor.raw_data().data());
  field->Resize(num_elements, 0);
  void* target_ptr = static_cast<void*>(field->mutable_data());
  memcpy(target_ptr, src_ptr, raw_size);

  return true;
}

bool IsOperator(const std::string& op_type) {

            

Reported by FlawFinder.

                      CAFFE_ENFORCE(onnx_tensor.raw_data().size() == sizeof(float));
        // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
        float f;
        memcpy(&f, onnx_tensor.raw_data().c_str(), sizeof(float));
        c2_values->set_f(f);
      }
    } else if (onnx_tensor.data_type() == TensorProto::DOUBLE) {
      c2_dtype->set_i(caffe2::TensorProto::DOUBLE);
      if (onnx_tensor.double_data_size() > 0) {

            

Reported by FlawFinder.

                      CAFFE_ENFORCE(onnx_tensor.raw_data().size() == sizeof(double));
        // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
        double d;
        memcpy(&d, onnx_tensor.raw_data().c_str(), sizeof(double));
        c2_values->set_f(static_cast<float>(d));
      }
    } else if (onnx_tensor.data_type() == TensorProto::INT64) {
      c2_dtype->set_i(caffe2::TensorProto::INT64);
      if (onnx_tensor.int64_data_size() > 0) {

            

Reported by FlawFinder.

                      CAFFE_ENFORCE(onnx_tensor.raw_data().size() == sizeof(int64_t));
        // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
        int64_t i;
        memcpy(&i, onnx_tensor.raw_data().c_str(), sizeof(int64_t));
        c2_values->set_i(i);
      }
    } else if (onnx_tensor.data_type() == TensorProto::INT32) {
      c2_dtype->set_i(caffe2::TensorProto::INT32);
      if (onnx_tensor.int32_data_size() > 0) {

            

Reported by FlawFinder.

                      CAFFE_ENFORCE(onnx_tensor.raw_data().size() == sizeof(int32_t));
        // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
        int32_t i;
        memcpy(&i, onnx_tensor.raw_data().c_str(), sizeof(int32_t));
        c2_values->set_i(i);
      }
    } else {
      // TODO: to support more data type
      std::stringstream oss;

            

Reported by FlawFinder.

              import pytest  # noqa: F401

default_rnns = ['cudnn', 'aten', 'jit', 'jit_premul', 'jit_premul_bias', 'jit_simple',
                         'jit_multilayer', 'py']
default_cnns = ['resnet18', 'resnet18_jit', 'resnet50', 'resnet50_jit']
all_nets = default_rnns + default_cnns

def pytest_generate_tests(metafunc):
    # This creates lists of tests to generate, can be customized

            

Reported by Pylint.

              import pytest  # noqa: F401

default_rnns = ['cudnn', 'aten', 'jit', 'jit_premul', 'jit_premul_bias', 'jit_simple',
                         'jit_multilayer', 'py']
default_cnns = ['resnet18', 'resnet18_jit', 'resnet50', 'resnet50_jit']
all_nets = default_rnns + default_cnns

def pytest_generate_tests(metafunc):
    # This creates lists of tests to generate, can be customized

            

Reported by Pylint.

              import pytest  # noqa: F401

default_rnns = ['cudnn', 'aten', 'jit', 'jit_premul', 'jit_premul_bias', 'jit_simple',
                         'jit_multilayer', 'py']
default_cnns = ['resnet18', 'resnet18_jit', 'resnet50', 'resnet50_jit']
all_nets = default_rnns + default_cnns

def pytest_generate_tests(metafunc):
    # This creates lists of tests to generate, can be customized

            

Reported by Pylint.

              default_cnns = ['resnet18', 'resnet18_jit', 'resnet50', 'resnet50_jit']
all_nets = default_rnns + default_cnns

def pytest_generate_tests(metafunc):
    # This creates lists of tests to generate, can be customized
    if metafunc.cls.__name__ == "TestBenchNetwork":
        metafunc.parametrize('net_name', all_nets, scope="class")
        metafunc.parametrize("executor", [metafunc.config.getoption("executor")], scope="class")
        metafunc.parametrize("fuser", [metafunc.config.getoption("fuser")], scope="class")

            

Reported by Pylint.

                      metafunc.parametrize("executor", [metafunc.config.getoption("executor")], scope="class")
        metafunc.parametrize("fuser", [metafunc.config.getoption("fuser")], scope="class")

def pytest_addoption(parser):
    parser.addoption("--fuser", default="old", help="fuser to use for benchmarks")
    parser.addoption("--executor", default="legacy", help="executor to use for benchmarks")

            

Reported by Pylint.

                      else:
            self.shape = get_categorical_limit(input_record)
            logger.warning(
                '{}: categorical_limit of lengths is not available, using '
                'categorical_limit of the keys: {}'.format(
                    str(input_record.lengths()), self.shape))

        self.pos_w = self.create_param(param_name='pos_w',
                                       shape=[self.shape, ],

            

Reported by Pylint.

              ## @package position_weighted
# Module caffe2.python.layers.position_weighted





import logging
import numpy as np

            

Reported by Pylint.

              logger = logging.getLogger(__name__)


class PositionWeighted(ModelLayer):
    def __init__(self, model, input_record, weight_optim=None,
                 name="position_weights"):
        super(PositionWeighted, self).__init__(model, name, input_record)

        assert isinstance(input_record, schema.List), "Incorrect input type"

            

Reported by Pylint.

              class PositionWeighted(ModelLayer):
    def __init__(self, model, input_record, weight_optim=None,
                 name="position_weights"):
        super(PositionWeighted, self).__init__(model, name, input_record)

        assert isinstance(input_record, schema.List), "Incorrect input type"
        length_metadata = input_record.lengths.metadata
        max_length = (length_metadata.categorical_limit if length_metadata is
                      not None else None)

            

Reported by Pylint.

                               name="position_weights"):
        super(PositionWeighted, self).__init__(model, name, input_record)

        assert isinstance(input_record, schema.List), "Incorrect input type"
        length_metadata = input_record.lengths.metadata
        max_length = (length_metadata.categorical_limit if length_metadata is
                      not None else None)
        if max_length is not None:
            self.shape = max_length

            

Reported by Bandit.

              ## @package batch_sigmoid_cross_entropy_loss
# Module caffe2.python.layers.batch_sigmoid_cross_entropy_loss





from caffe2.python import schema
from caffe2.python.layers.layers import ModelLayer

            

Reported by Pylint.

              import numpy as np


class BatchSigmoidCrossEntropyLoss(ModelLayer):
    def __init__(
        self,
        model,
        input_record,
        name='batch_sigmoid_cross_entropy_loss',

            

Reported by Pylint.

                      name='batch_sigmoid_cross_entropy_loss',
        **kwargs
    ):
        super(BatchSigmoidCrossEntropyLoss, self).__init__(
            model, name, input_record, **kwargs)

        assert schema.is_schema_subset(
            schema.Struct(
                ('label', schema.Scalar(np.float32)),

            

Reported by Pylint.

                      super(BatchSigmoidCrossEntropyLoss, self).__init__(
            model, name, input_record, **kwargs)

        assert schema.is_schema_subset(
            schema.Struct(
                ('label', schema.Scalar(np.float32)),
                ('prediction', schema.Scalar(np.float32)),
            ),
            input_record

            

Reported by Bandit.

                          ),
            input_record
        )
        assert input_record.prediction.field_type().shape == \
            input_record.label.field_type().shape, \
            "prediction and label must have the same shape"

        self.tags.update([Tags.EXCLUDE_FROM_PREDICTION])


            

Reported by Bandit.