OneFlow学习笔记：从OpExprInterpreter到OpKernel

撰文｜月踏

更新｜赵露阳

前文《OneFlow学习笔记：从Functor到OpExprInterpreter》讲了OpExprInterpreter的相关细节，再往下就是OneFlow中的虚拟机，它负责在eager模式下把指令（即op，在vm中称为指令）调度到具体的OpKernel上来执行。

1

Global简介

先看一个特殊的类Global，定义在
oneflow/core/common/global.h，这个类很简单，但是对于整个系统来说很重要，主要的几个接口如下：

template
class Global final {
 public:
  // 获取创建过的对象
  static T* Get() { ... }
  // 创建对象
  static void SetAllocated(T* val) { ... }
  template
  static T* New(Args&&... args) { ... }
  // 释放对象
  static void Delete() { ... }
  ...
};

这是一个可以根据指定顺序来创建全局单例对象的类，主要用在系统的初始化中，这样对于一些全局的对象在初始化的时候创建好，后续整个系统的各个模块就都可以使用了。

2

系统初始化过程

再继续看系统的初始化流程，首先在
python/oneflow/__init__.py+217中可以找到下面这句话：

__oneflow_global_unique_env = env_util.GetEnv()

GetEnv()方法在python/oneflow/framework/env_util.py中定义，其返回一个EnvHolder的Python对象，此对象初始化时，通过self._env_cxt = create_env()创建了OneFlow运行时所需要的环境上下文：

class EnvHolder(object):
    def __init__(self):
        if not HasAllMultiClientEnvVars():
            SetDefaultMultiClientEnvVars()
        self._env_cxt = create_env()
    ...


def create_env():
    """create environment


    Returns:
        Env: [description]
    """
    global default_env_proto
    assert len(default_env_proto.machine) > 0
    CompleteEnvProto(default_env_proto)
    if default_env_proto.ctrl_bootstrap_conf.world_size > 1:
        check_non_localhost_proxy_and_print_warning()
    return c_api_util.GetEnvContext(default_env_proto)

create_env()中，首先会通过CompleteEnvProto创建默认的env_proto对象，然后根据此env proto对象创建oneflow所需要的环境上下文env_ctx。

这里面和初始化相关的主线是GetEnvContext，其定位位于python/oneflow/framework/c_api_util.py+45：

def GetEnvContext(env_proto):
    assert type(env_proto) is env_pb2.EnvProto
    env_proto_str = text_format.MessageToString(env_proto)
    env_ctx = oneflow._oneflow_internal.EnvContext(env_proto_str)
    return env_ctx

这个EnvContext是oneflow内部导出的c api，其定义位于：
oneflow/api/python/env/env.cpp:L46。

其作用即初始化一个单例——env作用域对象EnvGlobalObjectsScope，并在其构造之初，通过
oneflow/core/job/env_global_objects_scope.cpp:L153的EnvGlobalObjectsScope::Init()方法初始化一些系统需要的其他全局单例对象/配置：

Maybe EnvGlobalObjectsScope::Init(const EnvProto& env_proto) {
  ...
  Global::New(env_proto);
  Global::New();
  ...
#ifdef WITH_CUDA
  Global::New();
  Global::New();
  Global::New();
#endif
 Global::New(Global::Get()->resource());
  Global::New();
  ... 
  return Maybe::Ok();
}

上面删去了很多代码，只展示了部分对象的创建，如：Global::New。

它会创建一个VirtualMachineScope的单例对象，这个类的构造函数因此会被执行一次，如下所示：

VirtualMachineScope::VirtualMachineScope(const Resource& resource) {
  Global::New(resource, GlobalProcessCtx::Rank());
}

在这个构造函数里，又通过Global创建了一个VirtualMachine的单例对象，这是个很重要的单例对象，后面讲虚拟机时会用到它，所以先在这一节引出。

3

StreamType和InstructionType的注册

还需要再看一部分和后面虚拟机非常相关的内容作为准备，它们是StreamType和InstructionType的注册，先看下面这段代码，位于oneflow/core/eager/cpu_opkernel_instruction_type.cpp+34：

COMMAND(vm::RegisterInstructionType("cpu.LocalCallOpKernel"));

COMMAND是一个宏，位于
oneflow/core/common/util.h+115，它的实现很巧妙，利用了匿名空间来保证在源文件定义的变量只在源文件可见，用CommandT和__LINE__在源文件中定义了一个唯一名字的struct，把注册语句放在它的构造函数中，然后再定义一个该struct的对象，其构造函数被自动执行的时候，注册语句也被执行：

#define COMMAND(...)                                                \
  namespace {                                                       \
  struct OF_PP_CAT(CommandT, __LINE__) {                            \
    OF_PP_CAT(CommandT, __LINE__)() { __VA_ARGS__; }                \
  };                                                                \
  OF_PP_CAT(CommandT, __LINE__) OF_PP_CAT(g_command_var, __LINE__); \
  }

再看实际的注册语句，它的模板参数是CpuLocalCallOpKernelInstructionType，定义在oneflow/core/eager/cpu_opkernel_instruction_type.cpp+27，如下所示：

class CpuLocalCallOpKernelInstructionType final : public LocalCallOpKernelInstructionType {
 public:
  CpuLocalCallOpKernelInstructionType() = default;
  ~CpuLocalCallOpKernelInstructionType() override = default;


  using stream_type = vm::CpuStreamType;
};

这段代码中的stream_type在下面会很有用，这段代码其实是把
CpuLocalCallOpKernelInstructionType类和vm::CpuStreamType类建立了关联，再继续看COMMAND宏中的注册语句，单独摘出来如下所示：

vm::RegisterInstructionType("cpu.LocalCallOpKernel")

RegisterInstructionType是一个模板函数，定义位于oneflow/core/vm/instruction_type.h+80：

template
void RegisterInstructionType(const std::string& instr_type_name) {
  RegisterInstrTypeId(instr_type_name, StaticGlobalStreamType());
}

以这里COMMAND的示例中对
CpuLocalCallOpKernelInstructionType的注册为例，按行来看，注册函数RegisterInstructionType主要内容在：oneflow/core/vm/instruction_type.cpp+54:

void RegisterInstrTypeId(const std::string& instruction_name, const StreamType* stream_type,
                         const InstructionType* instruction_type) {
  InstrTypeId instr_type_id;
  instr_type_id.__Init__(stream_type, instruction_type);
  CHECK(InstrTypeId4InstructionName()->emplace(instruction_name, instr_type_id).second);
}

实际做了下面几件事（CpuLocalCallOpKernelInstructionType的名字较长，为了方便表示，下面简称它为T）：

  • 初始化一个InstrTypeId对象，并调用其__Init__方法为其成员变量stream_type_和instruction_type_赋值，这里stream_type就是T::stream_type，即vm::CpuStreamType；instruction_type即指向T的指令类型的指针对象。
  • 通过InstrTypeId4InstructionName()方法拿到一个静态HashMap map对象的指针。
  • 将instruction_name（"cpu.LocalCallOpKernel"）作为key，InstrTypeId对象instr_type_id作为value插入这个map中。

4

虚拟机调度过程1

前文《OneFlow学习笔记：从Functor到OpExprInterpreter》讲到了调用PhysicalRun之前的mirror mode和eager mode的大概流程，已经准备好了输入输出的EagerBlobObject以及一些context信息和相关的device信息，在调用PhysicalRun这个函数之后，就进入了虚拟机的部分。

4.1 放指令线程

PhysicalRun接受一个call-back function作为参数，这个call-back函数中会调用builder->LocalCallOpKernel这个函数，并且以前面准备好的输入、输出、ctx、device作为参数来执行，先来看PhysicalRun函数，它定义在
oneflow/core/framework/instructions_builder.cpp+595：

Maybe PhysicalRun(const std::function(InstructionsBuilder*)>& Build) {
  vm::InstructionMsgList instruction_list;
  InstructionsBuilder instructions_builder(std::make_shared(),
                                           &instruction_list);
  JUST(Build(&instructions_builder));
  JUST(vm::Run(instructions_builder.mut_instruction_list()));
  return Maybe::Ok();
}

这里的Build就是刚从传进来的call-back函数，整理出来再来加深一下印象：

[&](InstructionsBuilder* builder) -> Maybe {
    return builder->LocalCallOpKernel(kernel, input_eager_blob_objects, output_eager_blob_objects, ctx, op_device);
}

在PhysicalRun中，以InstructionsBuilder对象为参数来调用这个call-back function，所以会执行InstructionsBuilder中的LocalCallOpKernel函数，这个函数位于
oneflow/core/framework/instructions_builder.cpp+347：

Maybe InstructionsBuilder::LocalCallOpKernel(...) {
  ...
  auto phy_instr_operand = JUST(vm::LocalCallOpKernelPhyInstrOperand::New(
      opkernel, input_eager_blob_objects, output_eager_blob_objects, consistent_tensor_infer_result,
      ctx, *one::CurrentDevVmDepObjectConsumeMode()));
  auto instruction = intrusive::make_shared(
      Global::Get()->mut_vm(), JUST(op_device->local_call_instruction_name()),
      parallel_desc_sym, phy_instr_operand);
  instruction_list_->EmplaceBack(std::move(instruction));
  ...
  return Maybe::Ok();
}

这个函数逻辑大概是把输入op相关的信息打包成一个vm::InstructionMsg对象，然后放到instruction_list_这个list中。

到这里前面的PhysicalRun中的Build部分就分析完了，继续看Build之后的逻辑vm::Run，它主要是调了
oneflow/core/vm/vm_util.cpp+34中的Run方法：

Maybe Run(vm::InstructionMsgList* instr_msg_list) {
  auto* virtual_machine = JUST(GlobalMaybe());
  JUST(virtual_machine->Receive(instr_msg_list));
  return Maybe::Ok();
}

这里通过GlobalMaybe来得到了在前面第一节OneFlow初始化中讲到的被创建好的VirtualMachine对象，这里调用了VirtualMachine中的Receive函数，位于
oneflow/core/vm/virtual_machine.cpp+204：

Maybe VirtualMachineEngine::Receive(
    intrusive::shared_ptr&& compute_instr_msg) {
  InstructionMsgList instr_msg_list;
  instr_msg_list.EmplaceBack(std::move(compute_instr_msg));
  return Receive(&instr_msg_list);
}

这里的vm_变量类型是intrusive::shared_ptr，在我们的示例中，会走到else分支，也就调用了VirtualMachineEngine的Receive函数，它位于oneflow/core/vm/virtual_machine_engine.cpp+422，VirtualMachineEngine是一个很大很复杂的类，这里我们不关注它的其它功能，只关注当前的流程，下面是Receive函数的代码：

Maybe VirtualMachineEngine::Receive(InstructionMsgList* compute_instr_msg_list) {
  OF_PROFILER_RANGE_PUSH("vm:Receive");
  INTRUSIVE_UNSAFE_FOR_EACH_PTR(compute_instr_msg, compute_instr_msg_list) {
    OF_PROFILER_RANGE_PUSH(compute_instr_msg->DebugName());
    OF_PROFILER_RANGE_POP();
  }
  bool old_list_empty = mut_pending_msg_list()->MoveFrom(compute_instr_msg_list);
  OF_PROFILER_RANGE_POP();
  return old_list_empty;
}


Maybe VirtualMachineEngine::Receive(
    intrusive::shared_ptr&& compute_instr_msg) {
  InstructionMsgList instr_msg_list;
  instr_msg_list.EmplaceBack(std::move(compute_instr_msg));
  return Receive(&instr_msg_list);
}

从这里看到并没有指令被执行，唯一的一条线索是传进来的compute_instr_msg_list最终被放入了mut_pending_msg_list()中，当前的线程只负责往队列里放指令，另外有线程会从队列里往外取指令来执行，所以继续搜下mut_pending_msg_list()会在哪里被用到，可以搜到在
oneflow/core/vm/virtual_machine_engine.cpp+514的Schedule函数中被调用，Schedule又在oneflow/core/vm/virtual_machine.cpp+291中的ScheduleLoop函数中被调用，这就引入了使用指令的线程。

4.2 用指令线程

直接看ScheduleLoop线程函数被启动的地方，它在VirtualMachine的构造函数中作为一个线程函数被创建和启动，VirtualMachine的构造函数位于
oneflow/core/vm/virtual_machine.cpp+114，如下所示：

VirtualMachine::VirtualMachine(const Resource& resource, int64_t this_machine_id)
    : vm_threads_closed_(false) {
  ...
  std::function SchedulerInitializer;
  GetSchedulerThreadInitializer(&SchedulerInitializer);
  schedule_thread_ = std::thread(&VirtualMachine::ScheduleLoop, this, SchedulerInitializer);
}

从前面第一节讲的的OneFlow初始化流程中可知，在OneFlow初始化的时候创建一个VirtualMachine的全局对象，自然其构造函数会被调用，所以这个VirtualMachine::ScheduleLoop线程函数在那时就被启动了，继续看ScheduleLoop的内容，位于oneflow/core/vm/virtual_machine.cpp+291：

void VirtualMachine::ScheduleLoop(const std::function& Initializer) {
  ...
  while (pending_notifier_.WaitAndClearNotifiedCnt() == kNotifierStatusSuccess) {
    ...
    do {
      ...
      do {
        ...
        do { vm->Schedule(schedule_ctx); } while (!vm->ThreadUnsafeEmpty());
        vm->MoveToGarbageMsgListAndNotifyGC(schedule_ctx);
      } while (++i < kNumSchedulingPerTimoutTest);
    } while (MicrosecondsFrom(start) < kWorkingMicroseconds);
  }
  ...
}

这里面最重要的是Schedule函数的调用，位于
oneflow/core/vm/virtual_machine_engine.cpp+514，简化代码如下：

void VirtualMachineEngine::Schedule() {
  if (...) { ReleaseFinishedInstructions(); }
  if (...) { TryRunBarrierInstruction(); }
  if (...) { HandleLocalPending(); }
  if (...) { DispatchAndPrescheduleInstructions(); }
}

这个函数里比较重要的两个函数是HandleLocalPending和DispatchAndPrescheduleInstructions，先看HandleLocalPending，位于oneflow/core/vm/virtual_machine_engine.cpp+62，它的精简代码如下：

void VirtualMachineEngine::HandlePending() {
  ...
  InstructionMsgList pending_instr_msgs;
  INTRUSIVE_FOR_EACH_PTR(instr_msg, &pending_instr_msgs) {
    MakeInstructions(instr_msg, /*out*/ &new_instruction_list);
  }
  ...
  INTRUSIVE_FOR_EACH_PTR(instruction, &new_instruction_list) {
    ConsumeMirroredObjects(instruction);
    if (likely(Dispatchable(instruction))) {
      mut_ready_instruction_list()->PushBack(instruction);
      new_instruction_list.Erase(instruction);
    }
  }
}

可见它的工作主要是通过MakeInstructions制作指令，然后把指令放入list，再看DispatchAndPrescheduleInstructions，它位于oneflow/core/vm/virtual_machine_engine.cpp+320：

void VirtualMachineEngine::DispatchAndPrescheduleInstructions() {
  ReadyInstructionList tmp_ready_instruction_list;
  mut_ready_instruction_list()->MoveTo(&tmp_ready_instruction_list);
  INTRUSIVE_FOR_EACH(instruction, &tmp_ready_instruction_list) {
    ...
    DispatchInstruction(instruction.Mutable());
    ...
  }
  ...
}

这个函数的主要工作是调用了DispatchInstruction，继续来看一下这个函数，位于
oneflow/core/vm/virtual_machine_engine.cpp+344：

void VirtualMachineEngine::DispatchInstruction(Instruction* instruction,
                                               const ScheduleCtx& schedule_ctx) {
  auto* stream = instruction->mut_stream();
  stream->mut_running_instruction_list()->PushBack(instruction);
  if (stream->active_stream_hook().empty()) { mut_active_stream_list()->PushBack(stream); }
  const auto& stream_type = stream->stream_type();
  if (OnSchedulerThread(stream_type)) {
    stream_type.Run(instruction);
  } else {
    stream->mut_thread_ctx()->mut_pending_instruction_list()->PushBack(instruction);
    schedule_ctx.OnWorkerLoadPending(stream->mut_thread_ctx());
  }
}

从这个函数中可以看出，指令被stream_type.Run来执行了，这里打断一下，用下面一节内容来追一下这里的stream_type从哪来的。

5

指令中的stream

从上面第四节的最后一段代码中，可以看到stream_type来自于stream，stream来自于Instruction，本节来追一下Instruction中的stream是怎么来的。

以mirror mode为例，代码会首先进入4.1节讲过的LocalCallOpKernel函数执行，位于
oneflow/core/framework/instructions_builder.cpp+347：

Maybe InstructionsBuilder::LocalCallOpKernel(..., Symbol op_device) {
  ...
  const auto& instruction_name = JUST(StreamRoleSwitch(
      stream->stream_role(), stream->device()->enum_type()));
  auto instruction = intrusive::make_shared(
      Global::Get()->mut_vm(), instruction_name, parallel_desc_sym,
      phy_instr_operand);
  instruction_list_->EmplaceBack(std::move(instruction));
  ...
  return Maybe::Ok();
}

这里主要是在创建指令instruction对象，创建完成后放入指令列表末尾。

这里先看一下instruction_name是怎么产生的，在GetCallInstructionName的结构体中维护着stream_role、stream type以及对应的指令名称instruction_name之间的映射关系，在StreamRoleSwitch模板中会转发至其Case方法，并最终返回instruction_name的字符串。

所以在我们的示例中会返回"cpu.LocalCallOpKernel"，在第三节中的注册示例中，可以看到以这个字符串为key，注册了CpuLocalCallOpKernelInstructionType这个类，它关联了vm::CpuStreamType类型，这些信息在后面都会用到。

再看InstructionMsg，它的定义位于
oneflow/core/vm/instruction.h+39：

class InstructionMsg final : public intrusive::Base {
  ...
  InstrTypeId instr_type_id_;
  std::string instr_type_name_;
  ...
  Stream* phy_instr_stream_;
};

InstructionMsg持有的InstrTypeId、Stream指针这两个成员和我们要追的stream的线索最相关，我们只需要关注这两个成员就好，在前面调用intrusive::make_shared(...)的时候，根据intrusive::make_shared的实现，会调用到InstructionMsg的下面这个__Init__函数，位于
oneflow/core/vm/instruction.cpp+42：

void InstructionMsg::__Init__(VirtualMachineEngine* vm, const std::string& instr_type_name,
                              const std::shared_ptr& phy_instr_parallel_desc,
                              const std::shared_ptr& phy_instr_operand) {
  __Init__();
  if (likely(phy_instr_parallel_desc)) {
    int device_id = phy_instr_parallel_desc->parallel_id2device_id().at(0);
    vm->GetCachedInstrTypeIdAndPhyInstrStream(instr_type_name, device_id, mut_instr_type_id(),
                                              &phy_instr_stream_);
  }
  ...
}

instr_type_id_和phy_instr_stream_的赋值就是在上面代码中的
GetCachedInstrTypeIdAndPhyInstrStream函数调用中完成的，定义位于oneflow/core/vm/virtual_machine_engine.cpp+383：

void VirtualMachineEngine::GetCachedInstrTypeIdAndPhyInstrStream(const std::string& instr_type_name,
                                                                 int device_id,
                                                                 InstrTypeId* instr_type_id,
                                                                 Stream** stream) {
  auto* cache = &instr_type_name2rt_instr_type_id_;
  auto iter = cache->find(instr_type_name);
  if (unlikely(iter == cache->end())) {
    const auto& instr_type_id_val = LookupInstrTypeId(instr_type_name);
    const auto* stream_type = &instr_type_id_val.stream_type();
    auto* stream_rt_desc = this->mut_stream_type2stream_rt_desc()->FindPtr(stream_type);
    iter = cache->emplace(instr_type_name, RtInstrTypeId(instr_type_id_val, stream_rt_desc)).first;
  }
  instr_type_id->CopyFrom(iter->second.instr_type_id());
  *stream = iter->second.GetStream(device_id);
}

这一段代码其实涉及的内容非常多，这里只能简单说一下，函数传进来的instr_type_name是"cpu.LocalCallOpKernel"，先在VirtualMachineEngine的下面这个map成员查询这个key：

std::map instr_type_name2rt_instr_type_id_;

这个map的value type是RtInstrTypeId，从它可以得到InstrTypeId和相应的Stream指针，它定义位于
oneflow/core/vm/runtime_instr_type_id.h+25：

class RtInstrTypeId final {
 public:
  RtInstrTypeId(const RtInstrTypeId&) = default;
  RtInstrTypeId(RtInstrTypeId&&) = default;
  ~RtInstrTypeId() = default;


  RtInstrTypeId(const InstrTypeId& instr_type_id, StreamRtDesc* stream_rt_desc)
      : instr_type_id_(instr_type_id), stream_rt_desc_(stream_rt_desc) {
    if (stream_rt_desc->stream_type().IsControlStreamType()) {
      get_stream_ = &StreamRtDesc::GetSoleStream;
    } else {
      get_stream_ = &StreamRtDesc::GetDeviceStream;
    }
  }


  const InstrTypeId& instr_type_id() const { return instr_type_id_; }
  Stream* GetStream(int device_id) const { return (stream_rt_desc_->*get_stream_)(device_id); }


 private:
  const InstrTypeId instr_type_id_;
  StreamRtDesc* stream_rt_desc_;
  Stream* (StreamRtDesc::*get_stream_)(int device_id) const;
};

如果没有从这个map中找到"cpu.LocalCallOpKernel"这个key，则会做下面操作：

if (unlikely(iter == cache->end())) {
  const auto& instr_type_id_val = LookupInstrTypeId(instr_type_name);
  const auto* stream_type = &instr_type_id_val.stream_type();
  auto* stream_rt_desc = this->mut_stream_type2stream_rt_desc()->FindPtr(stream_type);
  iter = cache->emplace(instr_type_name, RtInstrTypeId(instr_type_id_val, stream_rt_desc)).first;
}

先通过LookupInstrTypeId查询第三节注册的数据结构C，从而找到"cpu.LocalCallOpKernel"相应的InstrTypeId，它里面包含相关的StreamTypeId信息，再使用这个StreamTypeId，通过调用
mut_stream_type_id2stream_rt_desc()->FindPtr来找到对应的StreamRtDesc对象指针，然后根据instr_type_id_val和stream_rt_desc构造一个RtInstrTypeId对象作为value，维护到前面的map中，最后再从这个map得到InstrTypeId和相应的Stream指针返回。

顺便说一下
mut_stream_type_id2stream_rt_desc()对应的数据结构，它在VirtualMachineEngine的__Init__函数中（构造的时候被调用）被初始化，位于oneflow/core/vm/virtual_machine_engine.cpp+358：

void VirtualMachineEngine::__Init__(const VmDesc& vm_desc) {
  ...
  INTRUSIVE_UNSAFE_FOR_EACH_PTR(stream_desc, &vm_desc.stream_type_id2desc()) {
    if (stream_desc->num_threads() == 0) { continue; }
    auto stream_rt_desc = intrusive::make_shared(stream_desc);
    mut_stream_type_id2stream_rt_desc()->Insert(stream_rt_desc.Mutable());
    ...
  }
}

这样就知道了构造好的InstructionMsg对象是怎么包含的Stream信息，继续看InstructionMsg是怎么转换为Instruction对象的，在前面4.2节中讲的HandleLocalPending函数，位于oneflow/core/vm/virtual_machine_engine.cpp+62：

void VirtualMachineEngine::HandlePending() {
  ...
  InstructionMsgList pending_instr_msgs;
  INTRUSIVE_FOR_EACH_PTR(instr_msg, &pending_instr_msgs) {
    MakeInstructions(instr_msg, /*out*/ &new_instruction_list);
  }
  ...
  INTRUSIVE_FOR_EACH_PTR(instruction, &new_instruction_list) {
    ConsumeMirroredObjects(instruction);
    if (likely(Dispatchable(instruction))) {
      mut_ready_instruction_list()->PushBack(instruction);
      new_instruction_list.Erase(instruction);
    }
  }
}

其中的MakeInstructions会做这个转换，它的定义位于
oneflow/core/vm/virtual_machine_engine.cpp+226，原来的Stream信息也会被维护到这个新的数据结构中：

void VirtualMachineEngine::MakeInstructions(InstructionMsg* instr_msg,
                                            /*out*/ InstructionList* new_instruction_list) {
  const auto& instruction_type = instr_msg->instr_type_id().instruction_type();
  bool is_barrier_instruction = instruction_type.IsFrontSequential();
  Stream* stream = CHECK_NOTNULL(instr_msg->phy_instr_stream());
  const auto& pd = instr_msg->phy_instr_parallel_desc();
  intrusive::shared_ptr instr = stream->NewInstruction(instr_msg, pd);
  LivelyInstructionListPushBack(instr.Mutable());
  if (unlikely(is_barrier_instruction)) {
    mut_barrier_instruction_list()->PushBack(instr.Mutable());
  } else {
    new_instruction_list->PushBack(instr.Mutable());
  }
}

以上就是第四节末尾代码调用stream_type.Run()的时候，stream_type的由来，由前面的分析可知，它的实际类型就是和
CpuLocalCallOpKernelInstructionType建立好关联的vm::CpuStreamType！下面继续看虚拟机的调度过程。

6

虚拟机调度过程2

再继续看第四节的最后一段代码，为方便阅读，重新贴一下主要内容，位于
oneflow/core/vm/virtual_machine_engine.cpp+344：

void VirtualMachineEngine::DispatchInstruction(Instruction* instruction) {
  ...
  if (OnSchedulerThread(stream_type)) {
    stream_type.Run(instruction);
  } else {
    stream->mut_thread_ctx()->mut_pending_instruction_list()->PushBack(instruction);
    schedule_ctx.OnWorkerLoadPending(stream->mut_thread_ctx());
  }
  ...
}

从这个函数中可以看出，指令被stream_type.Run来执行了，从前面第五节的分析可知，stream_type是vm::CpuStreamType类型，继承自StreamType类型，StreamType定义于
oneflow/core/vm/stream_type.h，下面是它的主要接口：

class StreamType {
 public:
  virtual ~StreamType() = default;
  void Run(Instruction* instruction) const { Compute(instruction); }


  virtual const char* stream_tag() const = 0;
  virtual void InitDeviceCtx(std::unique_ptr* device_ctx, Stream* stream) const = 0;
  virtual void InitInstructionStatus(const Stream& stream,
                                     InstructionStatusBuffer* status_buffer) const = 0;
  virtual void DeleteInstructionStatus(const Stream& stream,
                                       InstructionStatusBuffer* status_buffer) const = 0;
  virtual bool QueryInstructionStatusDone(const Stream& stream,
                                          const InstructionStatusBuffer& status_buffer) const = 0;
  virtual void Compute(Instruction* instruction) const = 0;
  virtual intrusive::shared_ptr MakeStreamDesc(const Resource& resource,
                                                           int64_t this_machine_id) const = 0;
  virtual bool OnSchedulerThread() const = 0;
  virtual bool SupportingTransportInstructions() const = 0;
  virtual bool IsControlStreamType() const { return false; }


 protected:
  StreamType() = default;
};

这里面含有前面代码中用到的Run接口（stream_type.Run），它的实现位于Compute函数中。从StreamType的定义可以知道，这是一个虚接口，StreamType有下面这些子类实现：

OneFlow学习笔记：从OpExprInterpreter到OpKernel_第1张图片
图1

我们这里使用的是CpuStreamType，定义位于oneflow/core/vm/cpu_stream_type.h，它的Compute函数位于oneflow/core/vm/cpu_stream_type.cpp+50，如下所示：

void CpuStreamType::Compute(Instruction* instruction) const {
  ...
  {
    const auto& instr_type_id = instruction->mut_instr_msg()->instr_type_id();
    instr_type_id.instruction_type().Compute(instruction);
  }
  auto* status_buffer = instruction->mut_status_buffer();
  NaiveInstrStatusQuerier::MutCast(status_buffer->mut_buffer()->mut_data())->set_done();
  ...
}

可以看到这里又调用了instr_type_id.instruction_type().Compute()这个函数，这个Compute属于instruction_type()对应的类中，可以查到instruction_type()会返回一个InstructionType类型的const引用对象，所以关注InstructionType类即可，它的定义位于oneflow/core/vm/instruction_type.h，里面有Compute虚接口：

class InstructionType {
  ...
  virtual void Compute(Instruction* instruction) const = 0;
  virtual void ComputeInFuseMode(InstructionMsg* instr_msg) const { LOG(FATAL) << "UNIMPLEMENTED"; }
  ...
};

这也是个继承体系，InstructionType有非常多的子类，下面是我找到的一部分示例，没有列完：

OneFlow学习笔记：从OpExprInterpreter到OpKernel_第2张图片
我们调用的Compute位于上图中的
LocalCallOpKernelInstructionType，位于oneflow/core/eager/opkernel_instruction_type.cpp+150，它的Compute函数定义如下：

void LocalCallOpKernelInstructionType::Compute(vm::Instruction* instruction) const {
  CHECK_JUST(LocalCallOpKernelUtil::Compute(instruction));
}

可见又继续调用了
LocalCallOpKernelUtil::Compute，继续追这个函数，它的定义位于oneflow/core/eager/opkernel_instruction_type.cpp+44：

struct LocalCallOpKernelUtil final {
  static inline Maybe Compute(vm::Instruction* instruction) {
    ...
    OpKernelCompute(operand, device_ctx, state, cache);
    ...
    return Maybe::Ok();
  }
  ...
};

这里又继续调用了OpKernelCompute，在同一个类中：

struct LocalCallOpKernelUtil final {
  ...
  static inline void OpKernelCompute(LocalCallOpKernelPhyInstrOperand* operand,
                                     DeviceCtx* device_ctx, user_op::OpKernelState* state,
                                     const user_op::OpKernelCache* cache) {
    ...
    operand->user_opkernel()->Compute(compute_ctx, state, cache);
    ...
  }
};

其中user_opkernel()会返回一个user_op::OpKernel的指针，而这个OpKernel就是我们定义算子的时候必须要继承的一个基类，以我们的relu示例来说，relu的计算部分定义在
oneflow/user/kernels/relu_kernel.cpp，精简代码如下：

class ReluKernel final : public user_op::OpKernel, public user_op::CudaGraphSupport {
 private:
  void Compute(user_op::KernelComputeContext* ctx) const override {
    // do computing!
  }
};

至此，终于从上到下打通了一条执行路线！

Reference

本文主要梳理了OneFlow虚拟机的的作用和相关实现，主要参考的是OneFlow的官方代码和之前的一些相关文章，但限于篇幅和本人目前的认知，里面有很多地方还没有弄懂或者没有总结，比如指令边的部分，SkipList、SkipListHead、ListHookArray、ListHook、SkipListHook等基础数据结构的作用及实现细节等，需要继续学习的地方还有很多，继续加油～

下面是相关链接：

*（本文参考代码：

https://github.com/Oneflow-In...）*

特别感谢同事路强、俊丞、后江在我学习和理解这部分内容的过程中提供的帮助。

欢迎下载体验OneFlow v0.7.0最新版本：

https://github.com/Oneflow-In...

你可能感兴趣的:(学习笔记code虚拟机数据结构)

  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • 回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录leetcode算法职场和发展
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
  • 509. 斐波那契数(每日一题) lzyprime
    lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • python是什么意思中文-在python中%是什么意思 编程大乐趣
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
  • 数组去重 好奇的猫猫猫
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
  • Faiss Tips：高效向量搜索与聚类的利器 焦习娜Samantha
    FaissTips：高效向量搜索与聚类的利器faiss_tipsSomeusefultipsforfaiss项目地址:https://gitcode.com/gh_mirrors/fa/faiss_tips项目介绍Faiss是由FacebookAIResearch开发的一个用于高效相似性搜索和密集向量聚类的库。它支持多种硬件平台，包括CPU和GPU，能够在海量数据集上实现快速的近似最近邻搜索（AN
  • ARM中断处理过程 落汤老狗 嵌入式linux
    一、前言本文主要以ARM体系结构下的中断处理为例，讲述整个中断处理过程中的硬件行为和软件动作。具体整个处理过程分成三个步骤来描述：1、第二章描述了中断处理的准备过程2、第三章描述了当发生中的时候，ARM硬件的行为3、第四章描述了ARM的中断进入过程4、第五章描述了ARM的中断退出过程本文涉及的代码来自3.14内核。另外，本文注意描述ARM指令集的内容，有些sourcecode为了简短一些，删除了T
  • 回溯算法-重新安排行程 chirou_ 算法数据结构图论c++图搜索
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
  • Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redisbootstrap数据库
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
  • 基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python开发语言
    基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
  • C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享C++Leetcode题解
    题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
  • Faiss：高效相似性搜索与聚类的利器 网络·魚 大数据faiss
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
  • 数据结构之哈希表 X同学的开始 数据结构数据结构散列表
    哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 「豆包Marscode体验官」 | 云端 IDE 启动 & Rust 体验 张风捷特烈 iderust开发语言后端
    theme:cyanosis我正在参加「豆包MarsCode初体验」征文活动MarsCode可以看作一个运行在服务端的远程VSCode开发环境。对于我这种想要学习体验某些语言，但不想在电脑里装环境的人来说非常友好。本文就来介绍一下在MarsCode里，我的体验rust开发体验。一、MarsCode是什么它的本质是:提供代码助手和云端IDE服务的web网站，可通过下面的链接访问https://www
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • 数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列C语言
    文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
  • BART&BERT Ambition_LAO 深度学习
    BART和BERT都是基于Transformer架构的预训练语言模型。模型架构：BERT(BidirectionalEncoderRepresentationsfromTransformers)主要是一个编码器（Encoder）模型，它使用了Transformer的编码器部分来处理输入的文本，并生成文本的表示。BERT特别擅长理解语言的上下文，因为它在预训练阶段使用了掩码语言模型（MLM）任务，即
  • 第1步win10宿主机与虚拟机通过NAT共享上网互通 学习3人组 大数据大数据
    VM的CentOS采用NAT共用宿主机网卡宿主机器无法连接到虚拟CentOS要实现宿主机与虚拟机通信，原理就是给宿主机的网卡配置一个与虚拟机网关相同网段的IP地址，实现可以互通。1、查看虚拟机的IP地址2、编辑虚拟机的虚拟网络的NAT和DHCP的配置，设置虚拟机的网卡选择NAT共享模式3、宿主机的IP配置，确保vnet8的IPV4属性与虚拟机在同一网段4、ping测试连通性[root@localh
  • 语文主题教学学习笔记之87 东哥杂谈
    “语文主题教学”学习笔记之八十七（0125）今天继续学习小学语文主题教学的实践样态。板块三：教学中体现“书艺”味道。作为四大名著之一的《水浒传》，堪称我国文学宝库之经典。对从《水浒传》中摘选的单元，教师就要了解其原生态，即评书体特点。这也要求教师要了解一些常用的评书行话术语，然后在教学时适时地加入一些，让学生体味其文本中原有的特色。学生也要尽可能地通过朗读的方式，而不单是分析讲解的方式进行学习。细
  • [Python] 数据结构 详解及代码 AIAdvocate 算法python数据结构链表
    今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
  • 4.C_数据结构_队列 荣世蓥 数据结构数据结构
    概述什么是队列：队列是限定在两端进行插入操作和删除操作的线性表。具有先入先出(FIFO)的特点相关名词：队尾：写入数据的一段队头：读取数据的一段空队：队列中没有数据，队头指针=队尾指针满队：队列中存满了数据，队尾指针+1=队头指针循环队列1、基本内容循环队列是以数组形式构成的队列数据结构。循环队列的结构体如下：typedefintdata_t;//队列数据类型#defineN64//队列容量typ
  • ARM V8 base instruction -- Debug instructions xiaozhiwise Assemblyarm
    /**Debuginstructions*/BRK#imm16进入monitormodedebug，那里有on-chipdebugmonitorcodeHLT#imm16进入haltmodedebug，连接有外部调试硬件
  • ESP32-C3入门教程 网络篇⑩——基于esp_https_ota和MQTT实现开机主动升级和被动触发升级的OTA功能 小康师兄 ESP32-C3入门教程https服务器esp32OTAMQTT
    文章目录一、前言二、软件流程三、部分源码四、运行演示一、前言本文基于VSCodeIDE进行编程、编译、下载、运行等操作基础入门章节请查阅：ESP32-C3入门教程基础篇①——基于VSCode构建HelloWorld教程目录大纲请查阅：ESP32-C3入门教程——导读ESP32-C3入门教程网络篇⑨——基于esp_https_ota实现史上最简单的ESP32OTA远程固件升级功能二、软件流程
  • C++八股 Petrichorzncu 八股总结c++开发语言
    这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
  • vue+el-table 可输入表格使用上下键进行input框切换 以对_ vue学习记录vue.jsjavascript前端
    使用上下键进行完工数量这一列的切换-->//键盘触发事件show(ev,index){letnewIndex;letinputAll=document.querySelectorAll('.table_inputinput');//向上=38if(ev.keyCode==38){if(index==0){//如果是第一行,回到最后一个newIndex=inputAll.length-1}elsei
  • 【树一线性代数】005入门 Owlet_woodBird 算法
    Index本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376分析实现总结本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376已知非空二叉树T的结点值均为正整数，采用顺序存储方式保存，数据结构定义如下:t
  • python获取子进程返回值_Python对进程Multiprocessing子进程返回值 weixin_39752157 python获取子进程返回值
    在实际使用多进程的时候，可能需要获取到子进程运行的返回值。如果只是用来存储，则可以将返回值保存到一个数据结构中；如果需要判断此返回值，从而决定是否继续执行所有子进程，则会相对比较复杂。另外在Multiprocessing中，可以利用Process与Pool创建子进程，这两种用法在获取子进程返回值上的写法上也不相同。这篇中，我们直接上代码，分析多进程中获取子进程返回值的不同用法，以及优缺点。初级用法
  • HQL之投影查询 归来朝歌 HQLHibernate查询语句投影查询
            在HQL查询中，常常面临这样一个场景，对于多表查询，是要将一个表的对象查出来还是要只需要每个表中的几个字段，最后放在一起显示？ 针对上面的场景，如果需要将一个对象查出来： HQL语句写“from 对象”即可 Session session = HibernateUtil.openSession();
  • Spring整合redis bylijinnan redis
    pom.xml <dependencies> <!-- Spring Data - Redis Library --> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redi
  • org.hibernate.NonUniqueResultException: query did not return a unique result: 2 0624chenhong Hibernate
    参考：http://blog.csdn.net/qingfeilee/article/details/7052736 org.hibernate.NonUniqueResultException: query did not return a unique result: 2         在项目中出现了org.hiber
  • android动画效果 不懂事的小屁孩 android动画
    前几天弄alertdialog和popupwindow的时候，用到了android的动画效果，今天专门研究了一下关于android的动画效果，列出来，方便以后使用。 Android 平台提供了两类动画。 一类是Tween动画，就是对场景里的对象不断的进行图像变化来产生动画效果（旋转、平移、放缩和渐变）。 第二类就是 Frame动画，即顺序的播放事先做好的图像，与gif图片原理类似。
  • js delete 删除机理以及它的内存泄露问题的解决方案 换个号韩国红果果 JavaScript
    delete删除属性时只是解除了属性与对象的绑定，故当属性值为一个对象时，删除时会造成内存泄露  （其实还未删除） 举例： var person={name:{firstname:'bob'}} var p=person.name delete person.name p.firstname -->'bob' // 依然可以访问p.firstname，存在内存泄露
  • Oracle将零干预分析加入网络即服务计划 蓝儿唯美 oracle
    由Oracle通信技术部门主导的演示项目并没有在本月较早前法国南斯举行的行业集团TM论坛大会中获得嘉奖。但是，Oracle通信官员解雇致力于打造一个支持零干预分配和编制功能的网络即服务（NaaS）平台，帮助企业以更灵活和更适合云的方式实现通信服务提供商（CSP）的连接产品。这个Oracle主导的项目属于TM Forum Live!活动上展示的Catalyst计划的19个项目之一。Catalyst计
  • spring学习——springmvc（二） a-john springMVC
    Spring MVC提供了非常方便的文件上传功能。 1，配置Spring支持文件上传： DispatcherServlet本身并不知道如何处理multipart的表单数据，需要一个multipart解析器把POST请求的multipart数据中抽取出来，这样DispatcherServlet就能将其传递给我们的控制器了。为了在Spring中注册multipart解析器，需要声明一个实现了Mul
  • POJ-2828-Buy Tickets aijuans ACM_POJ
    POJ-2828-Buy Tickets http://poj.org/problem?id=2828 线段树，逆序插入 #include<iostream>#include<cstdio>#include<cstring>#include<cstdlib>using namespace std;#define N 200010struct
  • Java Ant build.xml详解 asia007 build.xml
    1,什么是antant是构建工具2,什么是构建概念到处可查到，形象来说，你要把代码从某个地方拿来，编译，再拷贝到某个地方去等等操作，当然不仅与此，但是主要用来干这个3,ant的好处跨平台   --因为ant是使用java实现的，所以它跨平台使用简单--与ant的兄弟make比起来语法清晰--同样是和make相比功能强大--ant能做的事情很多，可能你用了很久，你仍然不知道它能有
  • android按钮监听器的四种技术 百合不是茶 androidxml配置监听器实现接口
    android开发中经常会用到各种各样的监听器,android监听器的写法与java又有不同的地方;    1,activity中使用内部类实现接口 ,创建内部类实例  使用add方法  与java类似   创建监听器的实例 myLis lis = new myLis();   使用add方法给按钮添加监听器  
  • 软件架构师不等同于资深程序员 bijian1013 程序员架构师架构设计
            本文的作者Armel Nene是ETAPIX Global公司的首席架构师，他居住在伦敦，他参与过的开源项目包括 Apache Lucene,，Apache Nutch， Liferay 和 Pentaho等。         如今很多的公司
  • TeamForge Wiki Syntax & CollabNet User Information Center sunjing TeamForgeHow doAttachementAnchorWiki Syntax
    the CollabNet user information center http://help.collab.net/   How do I create a new Wiki page? A CollabNet TeamForge project can have any number of Wiki pages. All Wiki pages are linked, and
  • 【Redis四】Redis数据类型 bit1129 redis
    概述 Redis是一个高性能的数据结构服务器，称之为数据结构服务器的原因是，它提供了丰富的数据类型以满足不同的应用场景，本文对Redis的数据类型以及对这些类型可能的操作进行总结。 Redis常用的数据类型包括string、set、list、hash以及sorted set.Redis本身是K/V系统，这里的数据类型指的是value的类型，而不是key的类型，key的类型只有一种即string
  • SSH2整合-附源码 白糖_ eclipsespringtomcatHibernateGoogle
    今天用eclipse终于整合出了struts2+hibernate+spring框架。 我创建的是tomcat项目，需要有tomcat插件。导入项目以后，鼠标右键选择属性，然后再找到“tomcat”项，勾选一下“Is a tomcat project”即可。具体方法见源码里的jsp图片，sql也在源码里。     补充1：项目中部分jar包不是最新版的，可能导
  • [转]开源项目代码的学习方法 braveCS 学习方法
    转自： http://blog.sina.com.cn/s/blog_693458530100lk5m.html http://www.cnblogs.com/west-link/archive/2011/06/07/2074466.html   1）阅读features。以此来搞清楚该项目有哪些特性2）思考。想想如果自己来做有这些features的项目该如何构架3）下载并安装d
  • 编程之美-子数组的最大和（二维） bylijinnan 编程之美
    package beautyOfCoding; import java.util.Arrays; import java.util.Random; public class MaxSubArraySum2 { /** * 编程之美 子数组之和的最大值（二维） */ private static final int ROW = 5; private stat
  • 读书笔记-3 chengxuyuancsdn jquery笔记resultMap配置ibatis一对多配置
    1、resultMap配置 2、ibatis一对多配置 3、jquery笔记 1、resultMap配置 当<select resultMap="topic_data"> <resultMap id="topic_data">必须一一对应。 (1)<resultMap class="tblTopic&q
  • [物理与天文]物理学新进展 comsci
          如果我们必须获得某种地球上没有的矿石,才能够进行某些能量输出装置的设计和建造,而要获得这种矿石,又必须首先进行深空探测,而要进行深空探测,又必须获得这种能量输出装置,这个矛盾的循环,会导致地球联盟在与宇宙文明建立关系的时候,陷入困境       怎么办呢?  
  • Oracle 11g新特性:Automatic Diagnostic Repository daizj oracleADR
    Oracle Database 11g的FDI（Fault Diagnosability Infrastructure）是自动化诊断方面的又一增强。 FDI的一个关键组件是自动诊断库（Automatic Diagnostic Repository-ADR）。 在oracle 11g中，alert文件的信息是以xml的文件格式存在的，另外提供了普通文本格式的alert文件。 这两份log文
  • 简单排序:选择排序 dieslrae 选择排序
    public void selectSort(int[] array){ int select; for(int i=0;i<array.length;i++){ select = i; for(int k=i+1;k<array.leng
  • C语言学习六指针的经典程序，互换两个数字 dcj3sjt126com c
    示例程序，swap_1和swap_2都是错误的，推理从1开始推到2，2没完成，推到3就完成了 # include <stdio.h> void swap_1(int, int); void swap_2(int *, int *); void swap_3(int *, int *); int main(void) { int a = 3; int b =
  • php 5.4中php-fpm 的重启、终止操作命令 dcj3sjt126com PHP
    php 5.4中php-fpm 的重启、终止操作命令: 查看php运行目录命令：which php/usr/bin/php 查看php-fpm进程数：ps aux | grep -c php-fpm 查看运行内存/usr/bin/php  -i|grep mem 重启php-fpm/etc/init.d/php-fpm restart 在phpinfo()输出内容可以看到php
  • 线程同步工具类 shuizhaosi888 同步工具类
    同步工具类包括信号量（Semaphore）、栅栏（barrier）、闭锁（CountDownLatch）   闭锁（CountDownLatch） public class RunMain { public long timeTasks(int nThreads, final Runnable task) throws InterruptedException { fin
  • bleeding edge是什么意思 haojinghua DI
    不止一次，看到很多讲技术的文章里面出现过这个词语。今天终于弄懂了——通过朋友给的浏览软件，上了wiki。  我再一次感到，没有辞典能像WiKi一样，给出这样体贴人心、一清二楚的解释了。为了表达我对WiKi的喜爱，只好在此一一中英对照，给大家上次课。   In computer science, bleeding edge is a term that
  • c中实现utf8和gbk的互转 jimmee ciconvutf8&gbk编码
    #include <iconv.h> #include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <fcntl.h> #include <string.h> #include <sys/stat.h> int code_c
  • 大型分布式网站架构设计与实践 lilin530 应用服务器搜索引擎
    1.大型网站软件系统的特点？ a.高并发，大流量。 b.高可用。 c.海量数据。 d.用户分布广泛，网络情况复杂。 e.安全环境恶劣。 f.需求快速变更，发布频繁。 g.渐进式发展。 2.大型网站架构演化发展历程？ a.初始阶段的网站架构。 应用程序，数据库，文件等所有的资源都在一台服务器上。 b.应用服务器和数据服务器分离。 c.使用缓存改善网站性能。 d.使用应用
  • 在代码中获取Android theme中的attr属性值 OliveExcel androidtheme
    Android的Theme是由各种attr组合而成, 每个attr对应了这个属性的一个引用, 这个引用又可以是各种东西.   在某些情况下, 我们需要获取非自定义的主题下某个属性的内容 (比如拿到系统默认的配色colorAccent), 操作方式举例一则: int defaultColor = 0xFF000000; int[] attrsArray = { andorid.r.
  • 基于Zookeeper的分布式共享锁 roadrunners zookeeper分布式共享锁
    首先，说说我们的场景，订单服务是做成集群的，当两个以上结点同时收到一个相同订单的创建指令，这时并发就产生了，系统就会重复创建订单。等等......场景。这时，分布式共享锁就闪亮登场了。   共享锁在同一个进程中是很容易实现的，但在跨进程或者在不同Server之间就不好实现了。Zookeeper就很容易实现。具体的实现原理官网和其它网站也有翻译，这里就不在赘述了。   官
  • 两个容易被忽略的MySQL知识 tomcat_oracle mysql
    1、varchar(5)可以存储多少个汉字，多少个字母数字？ 　　相信有好多人应该跟我一样，对这个已经很熟悉了，根据经验我们能很快的做出决定，比如说用varchar(200)去存储url等等，但是，即使你用了很多次也很熟悉了，也有可能对上面的问题做出错误的回答。 　　这个问题我查了好多资料，有的人说是可以存储5个字符，2.5个汉字（每个汉字占用两个字节的话），有的人说这个要区分版本，5.0
  • zoj 3827 Information Entropy(水题) 阿尔萨斯 format
    题目链接：zoj 3827 Information Entropy 题目大意：三种底，计算和。 解题思路：调用库函数就可以直接算了，不过要注意Pi = 0的时候，不过它题目里居然也讲了。。。limp→0+plogb(p)=0，因为p是logp的高阶。 #include <cstdio> #include <cstring> #include <cmath&
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他