blocks|key|728200|text|Synthesis+OS基本上是根据应用程序接口调用对你的程序进行部分评估，并用结果替换操作系统代码。主要的好处是消除了大量的错误检查(因为如果你的程序不会要求操作系统做一些愚蠢的事情，它就不需要检查)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|728201|是的，这是运行时优化的一个例子。|728202|entityMap|0|LINK|mutability|MUTABLE|url|http://valerieaurora.org/synthesis/SynthesisOS/^0|0|C|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

The <a href="http://valerieaurora.org/synthesis/SynthesisOS/">Synthesis OS</a> basically partially evaluated your program with respect to API calls, and replaced OS code with the results. The main benefit is that lots of error checking went away (because if your program isn't going to ask the OS to do something stupid, it doesn't need to check).

Yes, that's an example of runtime optimization.

blocks|key|728251|text|这已经在计算机图形学中完成了，特别是用于优化目的的软件渲染器。在运行时，会检查许多参数的状态，并生成光栅化器代码的优化版本(潜在地消除了许多条件)，这使得人们可以更快地渲染图形基元，例如三角形。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|728252|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

This has been done in computer graphics, specifically software renderers for optimization purposes. At runtime the state of many parameters is examined and an optimized version of the rasterizer code is generated (potentially eliminating a lot of conditionals) which allows one to render graphics primitives e.g. triangles much faster.

blocks|key|728287|text|一些编译器使用它进行静态变量初始化，从而避免了后续访问的条件开销。换句话说，他们通过在第一次执行代码时用no-ops覆盖代码来实现“只执行一次代码”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|728288|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Some compilers used to use it for static variable initialization, avoiding the cost of a conditional for subsequent accesses. In other words they implement "execute this code only once" by overwriting that code with no-ops the first time it's executed.

blocks|key|944447|text|从操作系统内核的角度来看，每一个即时编译器和链接器运行时都会对程序文本进行自我修改。最突出的例子就是谷歌的V8+ECMA脚本解释器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|944448|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

From the view of an operating system kernel every Just In Time Compiler and Linker Runtime performs program text self modification. Prominent example would be Google's V8 ECMA Script Interpreter.

blocks|key|944517|text|自修改代码(实际上是“自生成”代码)的另一个原因是实现即时编译机制以提高性能。例如，读取代数表达式并对输入参数范围进行计算的程序可以在陈述计算之前将表达式转换为机器代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|944518|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Another reason of self-modifying code (actually a "self-generating" code) is to implement a Just-In-time compilation mechanism for performance. E.g. a program that reads an algebric expression and calculates it on a range of input parameters may convert the expression in machine code before stating the calculation.

blocks|key|728408|text|我已经实现了一个使用进化来创建最佳算法的程序。它使用自我修改的代码来修改DNA蓝图。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|728409|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I have implemented a program using evolution to create the best algorithm. It used self-modifying code to modify the DNA blueprint.

blocks|key|944580|text|你知道，硬件和software...one之间没有逻辑上的区别，这句老话也可以说代码和数据之间没有逻辑上的区别。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|944581|什么是自修改代码？将值放入执行流中的代码，以便可以将其解释为命令而不是数据。当然，在函数式语言中有这样一种理论观点，即实际上没有区别。我的意思是，在e上，可以在命令式语言和编译器/解释器中以一种直接的方式做到这一点，而不需要假设地位平等。|944582|我指的是在实际意义上，数据可以改变程序的执行路径(在某种意义上，这是非常明显的)。我在想一些类似编译器-编译器的东西，它创建一个表(一个数据数组)，在解析过程中遍历，从一个状态移动到另一个状态(以及修改其他变量)，就像程序如何从一个命令移动到另一个命令，修改过程中的变量。|944583|因此，即使在编译器创建代码空间并引用完全独立的数据空间(堆)的常见实例中，仍然可以修改数据以显式更改执行路径。|944584|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

You know the old chestnut that there is no logical difference between hardware and software...one can also say that there is no logical difference between code and data.

What is self-modifying code? Code that puts values in the execution stream so that it can be imterpreted not as data but as a command. Sure there is the theoretical viewpoint in functional languages that there really is no difference. I'm saying on e can do this in a straightforward manner in imperative languages and compiler/interpreters without the presumption of equal status.

What I'm referring to is in the practical sense that data can alter program execution paths (in some sense this is extremely obvious). I am thinking of something like a compiler-compiler that creates a table (an array of data) that one traverses through in parsing, moving from state to state (and also modifying other variables), just like how a program moves from command to command, modifying variables in the process.

So even in the usual instance of where a compiler creates code space and refers to a fully separate data space (the heap), one can still modify the data to explicitly change the execution path.

blocks|key|728516|text|最好的版本可能是Lisp宏。与C宏不同，C宏只是一个预处理器，Lisp允许您随时访问整个编程语言。这是lisp中最强大的特性，在任何其他语言中都不存在。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|728517|我绝对不是一个专家，但是让一个口齿不清的家伙来谈论它！他们说Lisp是最强大的语言是有原因的，聪明的人说他们可能是对的。|728518|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The best version of this may be Lisp Macros. Unlike C macros which are just a preprocessor Lisp lets you have access to the entire programming language at all times. This is about the most powerful feature in lisp and does not exist in any other language. 

I am by no means an expert but get one of the lisp guys talking about it! There is a reason
that they say that Lisp is the most powerful language around and the smart folks no that they are probably right.

blocks|key|944739|text|许多年前，我花了一个上午调试一些自修改代码，一条指令改变了下一条指令的目标地址，也就是说，我正在计算一个分支地址。它是用汇编语言编写的，当我一步一步地通过程序时，它工作得很好。但是当我运行这个程序时，它失败了。最终，我意识到机器正在从内存中获取2条指令，并且(当指令被放置在内存中时)我正在修改的指令已经被获取，因此机器正在执行指令的未修改(不正确)版本。当然，当我调试的时候，它一次只能执行一条指令。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|944740|我的观点是，自我修改的代码在测试/调试时可能非常麻烦，而且通常对机器的行为(无论是硬件还是虚拟的)都有隐藏的假设。此外，系统永远不能在(现在)多核机器上执行的各种线程/进程之间共享代码页。这会使虚拟内存的许多好处失效，等等。它还会使在硬件级别进行的分支优化失效。|944741|(注意-我没有将JIT包括在自修改代码的类别中。JIT正在将代码的一种表示形式转换为另一种表示形式，而不是修改代码)|944742|总而言之，这只是一个糟糕的想法--非常整洁，非常晦涩，但非常糟糕。|944743|当然，如果你只有一个8080和~512字节的内存，你可能不得不求助于这样的实践。|944744|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

Many years ago i spent a morning trying to debug some self-modifying code, one instruction changed the target address of the following instruction, i.e., i was computing a branch address. It was written in assembly language and worked perfectly when i stepped through the program one instruction at a time. But when i ran the program it failed. Eventually, i realized that the machine was fetching 2 instructions from memory and (as the instructions were laid out in memory) the instruction i was modifying had already been fetched and thus the machine was executing the unmodified (incorrect) version of the instruction. Of course, when i was debugging, it was only doing one instruction at a time.

My point, self-modifying code can be extremely nasty to test/debug and often has hidden assumptions as to the behavior of the machine (be it hardware or virtual). Moreover, the system could never share code pages among the various threads/processes executing on the (now) multi-core machines. This defeats many of the benefits to virtual memory, etc. It also would invalidate branch optimizations done at the hardware level.

(Note - i do not included JIT in the category of self-modifying code. JIT is translating from one representation of the code to an alternate representation, it is not modifying the code)

All, in all, it's just a bad idea - really neat, really obscure, but really bad.

of course - if all you have is an 8080 and ~512 bytes of memory you might have to resort to such practices.

blocks|key|944802|text|我对一个不断更新的数据库运行统计分析。每次执行代码时，我的统计模型都会被编写和重写，以适应可用的新数据。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|944803|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I run statistical analyses against a continually updated database. My statistical model is written and re-written each time the code is executed to accommodate new data that become available.

Can you think of any legitimate (smart) uses for runtime code modification (program modifying it's own code at runtime)? 

Modern operating systems seem to frown upon programs that do this since this technique has been used by viruses to avoid detection.

All I can think of is some kind of runtime optimization that would remove or add some code by knowing something at runtime which cannot be known at compile time.

Are there any smart cases of runtime code modification?

数据库

编译器

解释器

你能想到任何合法的(聪明的)用于运行时代码修改(程序在运行时修改自己的代码)的用途吗？现代操作系统似乎不喜欢这样做的程序，因为这种技术已经被病毒用来避免被检测到。我所能想到的是某种运行时优化，通过在运行时知道一些在编译时不知道的东西来删除或添加一些代码。

问有没有什么聪明的运行时代码修改案例？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问有没有什么聪明的运行时代码修改案例？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问有没有什么聪明的运行时代码修改案例？
EN