CN1900907A - 适配演进的计算机软件产品 - Google Patents

适配演进的计算机软件产品 Download PDF

Info

Publication number
CN1900907A
CN1900907A CNA2006101014454A CN200610101445A CN1900907A CN 1900907 A CN1900907 A CN 1900907A CN A2006101014454 A CNA2006101014454 A CN A2006101014454A CN 200610101445 A CN200610101445 A CN 200610101445A CN 1900907 A CN1900907 A CN 1900907A
Authority
CN
China
Prior art keywords
name
computer program
function
operating part
software
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Granted
Application number
CNA2006101014454A
Other languages
English (en)
Other versions
CN100511133C (zh
Inventor
M·W·霍赫
H·勒斯勒尔
P·萨博
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Alcatel CIT SA
Alcatel Lucent NV
Original Assignee
Alcatel NV
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Alcatel NV filed Critical Alcatel NV
Publication of CN1900907A publication Critical patent/CN1900907A/zh
Application granted granted Critical
Publication of CN100511133C publication Critical patent/CN100511133C/zh
Expired - Fee Related legal-status Critical Current
Anticipated expiration legal-status Critical

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/40—Transformation of program code
    • G06F8/41—Compilation
    • G06F8/44—Encoding
    • G06F8/443—Optimisation
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/3017—Runtime instruction translation, e.g. macros

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • General Engineering & Computer Science (AREA)
  • Software Systems (AREA)
  • Physics & Mathematics (AREA)
  • General Physics & Mathematics (AREA)
  • Stored Programmes (AREA)

Abstract

本发明涉及一种用于使计算机程序产品自动适配于环境的方法，所述计算机程序产品包括可执行部分和数据部分，所述方法包括以下步骤：针对环境配置所述计算机程序产品，并在该环境中执行软件。此外，所述方法包括以下步骤：观测可执行部分的执行效果(即度量行为)；利用软件分析被观测效果的相互关系；并且基于规则修改可执行部分以减小如低效或故障的不期望的观测效果。本发明也涉及自动适配的计算机程序产品，以及用于制造所述自动适配的计算机程序产品的方法。

Description

适配演进的计算机软件产品
技术领域
本发明涉及一种使计算机程序产品自动适配于环境的方法、自动适配的计算机程序产品，和用于制造所述自动适配的计算机程序产品的方法。
本发明基于优先权申请，欧洲专利05106615.7，在此将其引入作为参考。
背景技术
在早期计算的原始设置中，程序复杂度很小，以至于一个人的思想就能完全包括整个程序的活动，直到最小的细节。现在，尽管计算机的能力已经以持续的几何级数增加，然而人的能力却没有进展。为了从技术进步中获益，必须开发并使用更抽象的概念工具和编程语言。
尽管单个程序员可以做出很大贡献，然而复杂度级别已经远远超出一个人可以构思整个程序的范围，这个程序能够充分利用现有计算机。因此开发交换、协作、积累、构造的方法以精心制作复杂的程序非常重要；这是软件工程的领域。
在2001年10月中期，IBM发布了声明，指出管理当今计算系统的困难超过了单个软件环境的管理。将几个异构环境集成到公司范围的(corporate-wide)计算系统中的需要、以及超过公司边界而将其扩展到互联网的需要，引入了新的复杂度级别。计算系统的复杂度似乎接近人的能力的限制，然而朝向增加的互连通性和集成的步伐，毫不减弱地快速前进。
在2003年1月IEE Computer Society发表的Jeffrey O.Kephart和David M.Chess的论文“The Vision of Autonomic Computing”中，建议创建根据管理者目标管理自身的系统。如新的细胞在生物系统中建立自身一样不费力地集成新的组件。自动计算系统的本质是自管理，其意图是从系统操作和维护的细节中解放系统管理者，并为用户提供以最高性能运行的机器。如它们的生物学的同名物，在面对改变组件、工作量、要求和额外条件时，以及在面对无意或恶意的硬件或软件故障时，自动系统将维护并调节它们的操作。
自动系统可以持续监控它自己的使用，并且检查组件升级。如果它认为升级的公开性能(advertised feature)是值得的，则系统将安装它们，如果必要就重新配置自身，并且运行回归测试，以确保一切正常。当它检测到错误时，系统将回到较旧的版本，同时其自动问题确定算法试图隔离错误源。作者引用了自管理的四个方面：
                    表1
  概念  当前计算   自动化计算
  自配置  公司数据中心具有销售商和平台。安装、配置和集成系统费时且易于出错。   组件和系统的多个自动化配置遵循高级别策略。系统调整的中止是自动且无缝的。
  自优化  系统具有数百个人工设置(set)、非线性调整参数，并且它们的数量随每个版本而增加。   组件和系统持续寻找改善它们自身性能和效率的机会。
  自修复  大型复杂系统中的问题确定耗费编程团队数周的时间。   系统自动检测、诊断并修复局部软件和硬件问题。
  自保护  攻击和级联(cascading)故障的检测和恢复是人工的。   系统自动抵御恶意攻击或级联故障。其使用早期告警以预见并防止系统范围的故障。
例如在普遍计算中发现的多个应用情景具有一个共同方面：软件将面临持续改变的执行环境。为了保证无缝服务，协议、结构和应用必须能够适配于在例如网络、系统配置、可用资源、变化的策略中的改变。换言之，适配必须是任何移动软件系统的关键性能。
通过用于使计算机程序产品自动适配于环境的方法，解决了自动计算的显示(vision)以及去除后天的功能和结构需求的问题。
计算机程序通常包括可执行部分和数据部分，所述使计算机程序产品自动适配于环境的方法包括以下步骤：针对环境配置计算机程序产品，并且在该环境中执行软件，其中在程序内部观测执行的效果(effect)，即行为本身，即可执行部分；利用软件分析被观测效果的相互关系，并基于规则修改可执行部分以减小不期望的效果。
通过一种自动适配于环境的计算机程序产品而达到所述目的，所述计算机程序产品包括可执行部分和数据部分，所述计算机程序产品包括针对环境配置计算机程序产品以在该环境中执行该计算机程序产品的配置装置，其中所述计算机程序产品包括：观测装置，其用于观测执行的效果，即可执行部分的行为；推断装置，其用于利用所述计算机程序产品来分析被观测效果的相互关系；以及重新构造装置，其用于基于规则修改可执行部分以减小不期望的效果。
通过一种制造这种自动适配的计算机程序产品的方法而达到所述目的，所述方法包括以下步骤：通过集成用于观测执行的效果(即可执行部分的行为)的观测装置，来配置(furnishing)所述可执行部分；通过用于利用软件分析观测效果的相互关系的推断装置，来配置所述可执行部分；以及通过用于基于规则而修改可执行部分以减小不期望的效果的重新构造装置，来配置所述可执行部分。
换言之，建议用这样的设计来替换通常的静态软件设计：通过应用程序转换技术、解释器、抽象(虚拟)机、编译技术、智能代理技术和高阶编程来允许演进的需求，其中该静态软件设计不适合例如每天改变的环境中的普遍计算。例如代理(个体、自主服务，即独立的软件片段)的适配、修改和重新构造，使其能够在演进(改变)的需求的环境中运行。应当指出，在本上下文中，配置和适配以及修改这些词语变为同义词。
发明内容
基本思想是变形(morphing)能力，这是指动态修改其运行时间的能力。变形(或演进)是一种实际效果，其中个体(实例、代理)的集合涉及执行特定的任务，训练它们自己来增强它们解决任务的能力。
本发明也是一种优选地作为计算机软件而被实现的制造方法，以及一种具有系统结构的计算机软件产品，其中组件或部分被看作是自组织的独立实体，该实体重新构造通过内部观测的外部交互所激励的自身。因此，计算机软件产品包括可观测且演进的组件用于观测行为并改变自己。
这具有这样的优势：产品是自演进的软件。所述制造方法实现了改进的有效快速的原型化(prototyping)。产品本身能够动态适配于改变的环境和需求。这导致针对必要适配和修改的开发工作的减少，并且提高了开发速度。所述技术允许创建自修复的软件。通常的开发过程被简化并且变得更具交互性和迭代性。最后一项要点是，动态演进的软件组件将加速软件和联网技术，例如作为语义网络的基础，这是因为在代理团体中存在遗漏的技术，即除了对特定功能性的请求的删除之外，该功能性到请求实体的实际转移。本发明也适于自动减小软件熵，这产生了改进的软件设计。以变形环境和计算资源为代价，通过应用本发明可以达到所有所述及许多其它优势。
下面将通过比较传统应用的技术和根据本发明的方法来实现本发明的目的，以及它们的应用在根据本发明的计算机软件产品中导致怎样的结果。
附图说明
图1概略地示出了根据现有技术和根据本发明的制造方法；
图2示出了迭代制造过程的不同阶段的工作；
图3概略地示出了根据本发明的计算机软件产品的粗结构；
图4概略地示出了说明根据本发明方法的粗结构的组件的协作；
图5概略地示出了演进历史。
具体实施方式
通常计算机软件产品包括两个部分：用于存储并呈现信息的数据部分，和执行功能状态。在通常的编程语言中，这些例如呈现为变量值。目前，数据部分通常是基于数据类型、对象以及甚至是数据库，该数据库能够使对象持续。更高级的程序语言以及特别是非命令式语言，如ProLog或LISP，模糊了这两部分的隔离。然而，在有助于存储状态的部分(即特定的程序配置)和有助于被评估(执行的另一个术语)时改变这些状态的部分之间进行区分几乎是可能的，参见例如任何种类的正式语义描述，如可操作语义、逻辑语义或甚至是声明语义。
例如代码转换，以及高阶编程或自修改代码的任何应用，在这个定义中是例外的情况，所述转换似乎是可执行部分，并且所述代码是数据部分，尽管代码是可执行的。所述部分的定义具有这样的上下文：部分实际上被执行，即从可操作语义角度来说能够改变(抽象的)机器配置。模型在下面被简化并且被理解为操作，能够改变机器状态的代码部分，数据部分。简单来说：操作导致在状态变化时变得明显的动作。
自修改代码称为软件片段，它通过在进行时重写自身来达到它的目的。目前，这普遍被认为非常有害且严峻的，但是它通常是编程者工具箱中一种极佳的手段。
图1在左边示出了示例性迭代软件创建过程。其开始于初始规划1，接着是需求分析2和设计3，即或多或少将所需功能性转换为体系结构描述。可以在4实现结果，即就编程环境再形成所述结果，这导致可以在5对照需求而被测试的实现，即对照预期功能性。最终在6分析并评估差异，其导致额外的需求。另一个循环开始。最终，当如此完成需求的覆盖时，在7部署软件产品，即针对可以被看作是从创建阶段P1向可操作阶段P2转变的操作来分配该软件产品。
在如问题陈述中所指出的可操作阶段P2中，通常出现其它需求，而另外几个需求消失。假设软件产品自身能够建立其它迭代以适配于改变的需求，过程继续进行到另一个需求分析8，然后是重新设计9，以及重新实现10。可以在11针对测试和度量来执行这个重新实现，并且如果在覆盖额外需求时成功进行了修改，则最终在12进行评估。显然，所述过程也是迭代的，这产生了演进的软件产品。所述重新实现是软件产品的版本，并且为了实现演进跟踪并反向追踪演进，使重新实现持续是优选的，即冻结中间部署13。
构建软件的任何过程的中心是程序编码。为了增强这些过程，将程序员从所有重复且概念上冗余的动作中解放出来，以使程序员可以专注于编程的本质，即关注没有被解决的问题。
读取、转换或写其它程序的编程领域的理论，包括概念函数式编程、宏编程，自然地出现在软件开发链中，其中它扮演了很重要的角色，它仅是编译器、解释器、调试器的形式。然而，元编程(meta-programming)从未被集成到开发过程中，并且获得其角色的感知(即软件内部的可观测属性)是这个领域中的一个进步。
添加(编程)对象的正交持续(orthogonal persistence)是另一个进步。开发冻结13强制所述正交持续，其中该正交持续是一种其中对象持续直到不再被需要的属性，利用动态优化代码的自动一致性管理的程序二进制码的编译和管理，利用结构驱动的用户连接的用户接口驱动的编程，利用隐式自动分发的显式人工联网。
可操作阶段需要元编程。元编程是操纵程序的活动性，其反过来操纵程序。所述阶段也需要反映(reflection)。反映是系统充分认识自己的能力，从而动态元编程它们自己的行为、使它们自己适配于改变的环境、并将程序员和管理员从当前需要人工完成的许多任务中解放出来。
反映允许系统结构的动态扩展、如果没有反映，则必须重新构造新的系统，并且例如每次结构改变时重新启动。
在技术的级别，以上内容都意味着服务的中断、服务的不可靠、服务的拒绝和进展的未知；但是在社会心理的级别，反映的缺乏也意味着人们必须进行不可逆转的静态结构选择，并且不考虑结构改变。反映是一种技术优势，但是也是一种社会心理的需求，其允许通过演进概念结构而不管历史选择的个体进展，以及通过统一用户情况而不管个体和非共享背景的多样性的团体进展。
实际挑战是构建这样的系统：可以一致地调整单独开发的性能，其中每个性能关于其它性能而处理计算的不同方面。如LISP的高级编程语言能够表达逻辑推理(包括商数)和计算反映二者，即能够指定、实现并任意检验分离软件组件之间复杂的后天关系。
图3示出了粗结构，其能够解决元编程和反映。作为通常开发的软件产品，假设程序P由观测器O来观测，这由程序P和观测器O之间的箭头表示。观测器具有一种对执行程序时所发生事情的警觉或感知。只要观测匹配于元编程规则，就从观测器O触发效应器E以重新构造程序P。这个通用结构和通用协作实现了自修改代码的显示。
图4精炼了所述结构。程序P包括可执行部分EX，其被配置(intrumented)用于由构成观测器O一部分的测量组件ME所执行的测量。例如通过比较识别器RE处的重构试探法(re-factoring heuristics)和所述测量，来评估该测量。当指示重构时，触发作为效应器E一部分的重构部件，来重新构造例如代码CO，可以从该代码得出新的可执行部分。重构部件可以记录它的动作，并且使得旧的和新的版次(revision)持续，其是由版次管理部件RM来管理的。
下面示例性地概述了如何配置LISP程序P以示出观测器O的可行性。所述技术的创新在于仅在可观测软件属性上限制了观测器，并且没有试图观测软件如何适合于软件环境。
将所述技术转换到如逻辑编程的另一编程范例十分直观，以例如使用以谓语构建的“再断言”来重新构造逻辑程序并通过添加合适的约束变量给ProLog中的谓语来配置从句。在代表面向对象的编程范例的Smalltalk中，配置(instrumentation)可以被集成到开发环境或对象元类中。
在LISP中，定义操作符适于配置LISP代码，例如通过观测作为软件属性的数据部分，其在所述例子中是LISP变量的观测。
                                      表10
(defclass DEFVAR-Class()((number-of-vars:allocation:class:initform 0:accessor number-of-vars)(variable-list:allocation:class:initform(make-hash-table:test′equal):accessor variable-list)(name:initform nil:initarg:name:accessor name)(value  :initform nil:initarg:value:accessor value)(file  :initform"":initarg:file:accessor file)));;etc
(defmethod initialize-instance:after((defvar-obj DEFVAR-Class)&rest args)(declare(ignore args));(incf(slot-value defvar-obj′number-of-vars)))
(defmethod morph-insert-into-varlist((defvar-obj DEFVAR-Class))(with-slots(name variable-list)defvar-obj(let((inst(gethash name variable-list)))(setf(gethash name variable-list)defvar-obj)(if(not inst)(incf(slot-value defvar-obj′number-of-vars)));(format t"registering～s in variable-list～%"name))))
(defmethod morph-remove-from-varlist((defvar-obj DEFVAR-Class))(with-slots(name variable-list)defvar-obj(when(gethash name variable-list)(remhash name variable-list)(decf(slot-value defvar-obj′number-of-vars));(format t"removing from variable-list:～s～%"name))))
DEFVAR类具有对变量的示例属性建模的几个槽(slot)，以及修改这些标记的几个方法，即维护所述描述对象的一致性。
                             表11
(defun morph-var-instance(var-name)(let*((proto(class-prototype(find-class′DEFVAR-Class))))(and proto(gethash var-name(variable-list proto)))))
(defun morpf-var-statistic(variable-name slot-name)"Returns the value of the slot-name of the defvar-instance"(let*((proto(class-prototype(find-class′DEFVAR-Class)))(instance(and proto(gethash variable-name(variable-list proto)))))(cond((and instance(equal variable-name(name instance)))(slot-value instance slot-name))(t(format t"variable～s not found～%"variable-name)))))
(defmacro defvar*(name&optional(initial-value nil initial-value-p)(documentation nil documentation-p));;-------------------------------;;;(register-defun name lambda-list forms)(let((inst(make-instance′DEFVAR-Class:name name:value initial-value:file"/usr/morphing/foo.lisp")))(morph-insert-into-varlist inst));;(print"registering DEFVAR in variable-list");;----------------------------`(progn(declaim(special,name)),(when initial-value-p`(unless(boundp′,name)(setf(symbol-value′,name),initial-value))),(when documentation-p`(setf(documentation′,name′variable)′,documentation))′,name))
通过宏defvar*增强编程环境，其在定义变量时创建描述对象。
典型地，变量的一致重命名，关于是否正确初始化变量的检测，或变量的使用，是难于处理的。这个相当原始的观测器能够应付所述困难，并且允许例如通过(morph-var-statistic‘x’value)来探索(explore)变量的初始值。
观测器DEFVAR类是能够存储变量属性的数据结构，所述属性例如它们的位置、它们的使用、值-通常是所有内在的可观测属性，甚至是变量之间的关系。
当定义变量时通过配置观测器的宏defvar*来扩展语言本身。观测在通过下一个代码引用(excerpt)所示例性示出的函数之间的关系是很困难的。
为了实现动态、适配的软件系统，扩展编程语言来支持反映；这称作感知。其包括对行为的动态修改的支持，即自修改代码，或易变的元对象协议。LISP中的宏似乎是进行上述操作的适当工具。
DEFUN类对defun所定义的函数进行建模。DEFUN类的实例“知道”其依据语法的形式(名称、签名、主体...)，其文件位置。此外，触发所述函数的函数名称，和由该函数触发的函数名称，作为关系的例子。任何时候用宏defun*定义函数，所述类的实例被创建并被插入类-变量函数列表的协议。在程序开发期间，所述类的实例获取关于它们自己的知识，并提供信息给“感知“层，以支持关于当前程序结构的推理。以下作为例子而说明了应用。
           表12
(defpackage:Memoization(:nicknames:Memo)(:use:common-lisp)(:export:Def-Memo-Fun:Memoize:Memoize-Functions:Unmemoize:Unmemoize-Functions:Unmemoize-All-Functions:Rememoize:Rememoize-Functions:Clear-Memo-Table:Clear-Memo-Tables:Save-Memo-Table:Memoized-Function-Call-Count:Memoized-Time:With-Memoization:Without-Memoization:Memoized-Function-Names:Compile-Memoization-System
          :Load-Memoization-System:Time-Form))(defpackage:morph(:use:common-lisp:Memoization)(:export:defun*));;------------ load something ------------------(defvar*morph-path*"D:/Documents and Settings/li62794/Desktop/programming/")(defvar*memo-package*(concatenate′string*morph-path*"Load-Memoization.lisp"))(load*memo-package*)
;;In order to implement dynamic,adaptive software systems,programming;;languages must support REASONING ABOUT THEIR OWN STRUCTURE,;;PERFORMANCE,AND ENVIRONMENT(often called"reflection"),here called;;"awareness".;;Furthermore,there must be support for dynamic modification of behavior;;(think self-modifying code,or a"mutable MOP(Meta Object Protocol)").;;Finally,this should all be efficient;in particular,code that does not make use;;of self reflection or modification should not take a performance hit.;;-------------------------------;;DEFUN-Class models the function defined by defun.;;An instance of DEFUN-Class;;"knows"its syntactic forms(name,signature,body，...),its file location.;;Furthermore the names of the functions,which triggers this function and the;;names of the functions,which are triggered by this function.Anytime a function;;is defined with the macro<defun*>an instance of this class will be created and;;inserted into the protocol of the class-variable<function-list>.During;;program development instances of this class acquire knowledge about;;themselves and give information to the"awareness"-layer to support;;reasoning about the current structure of the program.(in-package:morph)
;;--------------------- utils ---------------------(defun split-body-into-parts(body)"Returns the declares,the doc string,and any forms in BODY."(flet((ret(dec doc body)(retum-from split-body-into-parts(values dec(when doc(list doc))body))))(loopwith doc-string=nilwith declares=′()for form*on body
       for form=(car form*)do(cond((and(stringp form)(cdr form*))(setf doc-string form))((stringp form)(ret declares doc-string form*))((and(consp form)(eql′cl:declare(car form)))(push form declares))(t(ret declares doc-string form*))))))
;;---------- DEFUN awareness ------------------(defclass DEFUN-Class()((nr-of-defuns:allocation:class:initform 0:accessor nr-of-defuns)(function-list:allocation:class:initform(make-hash-table:test′equal):accessor function-list)(call-stack :allocation:class:initform nil:reader call-stack)(callers  :initform nil:initarg:callers:reader callers)(callees   :initform nil:initarg:callees:accessor callees)(nr-of-funcalls   :initform 0:initarg:nr-of-funcalls:accessor nr-of-funcalls)(name    :initform nil:initarg:name:accessor name)(comments:initform"":initarg:comments:accessor comments)(parameters:initform nil:initarg:parameters:accessor parameters)(logic :initform nil:initarg:logic:accessor logic)(memoized-logic  :initform nil:initarg:memoized-logic
            :accessor memoized-logic)(recursive-p   :initform nil:initarg:recursive-p:accessor recursive-p)(file  :initform"":initarg:file:accessor file)))
(defmethod initialize-instance:after((defun-obj DEFUN-Class)&rest args)(declare(ignore args));(incf(slot-value defun-obj′nr-of-defuns));;or is this better??;;(with-slots(nr-of-defuns)defun-obj;;(incf nr-of-defuns)))
(defmethod(setf nr-of-funcalls):after(value(defun-obj DEFUN-Class))"triggers a reaction if this slot has been changed"(declare(ignore value));(format t"nr-of-funcalls=～a～%"(nr-of-funcalls defun-obj)))
(defmethod reset-statistics((defun-obj DEFUN-Class))"resets numbers-of callers,etc.to init values"(with-slots(name callers callees nr-of-funcalls)defun-obj(setf callers nil)(setf callees nil)(setf nr-of-funcalls 0);(format t"clearing instance of～a～%"name)))
(defmethod morph-insert-into-funlist((defun-obj DEFUN-Class))(with-slots(name function-list)defun-obj(let((inst(gethash name function-list)))(setf(gethash name function-list)defun-obj)(if(not inst)(incf(slot-value defun-obj′nr-of-defuns)));(format t"registering～s in function-list～%"name))))
(defmethod morph-remove-from-funlist((defun-obj DEFUN-Class))(with-slots(name function-list)defun-obj(when(gethash name function-list)(remhash name function-list)(decf(slot-value defun-obj′nr-of-defuns))
        ;(format t"removing from function-list:～s～%"name))))
(defmethod morph-enter-call-stack((defun-obj DEFUN-Class))(with-slots(name callees function-list call-stack recursive-p)defun-obj(let*((top-name(first call-stack))(top-name-instance(and top-name(gethash top-name function-list))))(cond((and top-name-instance(not(member name(slot-value top-name-instance′callers))))(push name(slot-value top-name-instance′callers)))((and top-name-instance(not(member top-name callees)))(push top-name callees))(t()))(when(and(equal top-name name)(not recursive-p));;mark as a recursive function(setf recursive-p t))(push name call-stack))))
(defmethod morph-leave-call-stack((defun-obj DEFUN-Class))(with-slots(name function-list call-stack)defun-obj(let((top-name(first call-stack)))(if(equal top-name name)(pop call-stack)))))
(defmethod morph-memoize((defun-obj DEFUN-Class)&key(Test#′equal)(Key#′identity)(Hash-Table-Source:Create))"TRUE MORPHING!!Replaces the body of the original function by a NEW one!"(with-slots(name parameters logic memoized-logic)defun-obj(setf memoized-logic`(let((Hash-Table(ecase Hash-Table-Source(:Create       (make-hash-table:test Test))(:Disk          (Load-Saved-Memo-Table name))(:Old-Function(get Function-Name:Memo-Table)))))(setf(get name:Memo-Table)Hash-Table)(setf(get name:Unmemoized-Function)Function)(setf(get name:Memo-Table-Test)Test)(proclaim`(notinline,name))(declare(optimize(speed 3)(compilation-speed 0)(space 0)#+:allegro(debug 0)(safety 0)))(let((Hash-Key(funcall Key parameters)))(multiple-value-bind(Value Found?)(gethash Hash-Key Hash-Table)
       (cond(Found?(incf(the fixnum(get name:Hash-Table-Lookups)))Value)(t(incf(the fixnum(get name:Original-Function-Calls)))(setf(gethash Hash-Key Hash-Table),logic)))))))(Memoize name)))(defun morph-measure-memoization(function-name args)"yields two values:the computed result and the time differencebetween the unmemoized(origin)and the memoized version"(let((start1 0)(time1 0)(start2 0)(time2 0)(retum-val nil))(setq start1(get-internal-real-time))(setq return-val(funcall function-name args));;the time the origin function nedded(setq time1(-(get-internal-real-time)start1))`(progn(Memoize,function-name)(setq start2(get-intemal-real-time))(funcall function-name args);;the time the memoized function nedded(setq time2(-(get-internal-real-time)start2))(Unmemoize,function-name));;result and time-difference(values return-val(/(-time1 time2)(*1.0intemal-time-units-per-second)))))
(defun morph-funcall(function-name)"First check if the<name>is a morphing function.Than increase the counting slot<nr-of-funcalls>than update callers and callees list using the<call-stack>"(let*((proto(clos:class-prototype(find-class′DEFUN-Class)))(instance(and proto(gethash function-name(function-list proto)))))(cond((equal function-name(slot-value instance′name))(setf(nr-of-funcalls instance)(+(nr-of-funcalls instance)1))(morph-enter-call-stack instance))(t(format t"morph-funcall:function～s～%not foun d"function-name)))))
(defgeneric defun-entry-handler(name args);;define EQL methods on this if you want.(:method((name t)args)(declare(ignore args))
       ;(format*trace-output*"～&Enter～S～:S～%"name args)(morph-funcall name)))(defgeneric defun-exit-handler(name args&optional aborted);;ABORTED will be true if the call is being aborted by a non-local;;exit of some kind.;;define EQL methods on this if you want(:method((name t)args&optional(aborted nil))(if aborted(format*trace-output*"～&Exit～S～:S～:[～;(aborted)～]～%"name argsaborted))(let*((proto(clos:class-prototype(find-class′DEFUN-Class)))(instance(and proto(gethash name(function-list proto)))))(when instance(morph-leave-call-stack instance)))))(defmacro define-morphed-function(name arglist&body body)(let((argsn(make-symbol"ARGS"))(abortedn(make-symbol"ABORTED")))`(defun,name(&rest,argsn)(declare(dynamic-extent,argsn));is this safe?What??(let((,abortedn t))(unwind-protect(progn(defun-entry-handler′,name,argsn)(multiple-value-prog1(block,name(apply#′(lambda,arglist,@body),argsn))(setf,abortedn nil)))(defun-exit-handler′,name,argsn,abortedn))))))(defmacro defun*(name arglist&body body)"Inj ects morhing instrumentation into the function definition"(multiple-value-bind(dec doc bod)(split-body-into-parts body)`(let((foo(define-morphed-finction,name,arglist,@body))(defun-instance(make-instance′DEFUN-Class:name′,name:parameters′,arglist:comments′,(car doc):logic′,(car bod):file"/usr/morphing/foo.lisp")));;(register defun:name arglist body)(if foo(morph-insert-into-funlist defun-instance))foo)))(defmacro define-cloned-function(cname arglist &body body)(let((argsn(make-symbol"ARGS")))
   `(defun,cname(&rest,argsn)(declare(dynamic-extent,argsn))(if(t);;stack-top=cname(multiple-value-prog1(block,cname(apply#′(lambda,arglist,@body),argsn)))))))
(defun morph-fun-instance(function-name)(let*((proto(clos:class-prototype(find-class′DEFUN-Class))))(and proto(gethash function-name(function-list proto)))))(defun morph-func-statistic(function-name slot-name)"Returns the value of the slot-name of the function-instance with name function-name"(let*((proto(clos:class-prototype(find-class′DEFUN-Class)))(instance(and proto(gethash function-name(function-list proto)))))(cond((and instance(equal function-name(name instance)))(slot-value instance slot-name))(t(format t"function～s not found～%"function-name)))))
感知类对函数的观测属性进行建模，即角色，与其它部分的关系，和软件中的角色，例如调用方、被调用方和调用数目等。为了探索所述观测器的能力，建议在LISP执行环境中测试所述代码。
                                  表13
CL-USER           1         >               (load        "D:/Documents       andSettings/li62794/Desktop/programming/def-morph.lisp");           Loading           text         file          D:Documents        andSettingsli62794Desktopprogrammingdef-morph.lisp;                 Loading         text       file         D:Documents       andSettingsli62794DesktopprogrammingLoad-Memoization.lisp;                    Loading      fasl     file       C:Program  FilesLispWorksPersonal1ib4-4-0-0load-on-demandpclmacrosloop.fsl;;;Loading the Common Lisp Automatic Memoization Package;;;(CLAMP)from D:/Documents and Settings/li62794/Desktop/programming/.;;;To change this location,see Memo::*Memoization-Base-Directory*;;;in the Load-Memoization file.;;;;;;The files to be loaded are;;;Save-Memo-Table,Memoization,Simple-Metering,and Memoization-Examples.;;;Any of these except Memoization are optional.See;;;Memo::*Memoization-File-Names*in Load-Memoization.
;;;;;;CLAMP assumes that Lisp source files end in′.lisp′and;;;compiled files end in′.fsl′.To change these assumptions,;;;see Memo::*Source-File-Extension*and;;;Memo::*Compiled-File-Extension*in Load-Memoization.;;;;;;These loadup messages can be suppressed by setting;;;User::*Verbose-Memoization-Load?*to NIL before loading the;;;Load-Memoization file.;;;;                       Loading       fasl     file       D:Documents    andSettingsli62794DesktopprogrammingSave-Memo-Table.fsl;                       Loading       fasl     file       D:Documents    andSettingsli62794DesktopprogrammingMemoization.fsl;                       Loading       fasl     file       D:Documents    andSettingsli62794DesktopprogrammingSimple-Metering.fsl;                       Loading       fasl     file       D:Documents    andSettingsli62794DesktopprogrammingMemoization-Examples.fsl;;;;;;Memoization routines are in MEMOIZATION(MEMO)package.;;;Use(in-package:Memo)or;;;    (use-package:Memo[<Package>])to use them.;;;;;;The very first time,you need to do;;;(Memo:Compile-Memoization-System),then;;;(Memo:Load-Memoization-System);;;Thereafter,just load this file,which will load the rest.;                  Loading        fasl         file      D:Documents    andSettingsli62794Desktopprogrammingre-defun.fsl;                  Loading        text         file      D:Documents    andSettings1i62794Desktopprogrammingre-defvar.lisp#P"D:/Documents and Settings/li62794/Desktop/programming/def-morph.lisp"
CL-USER 2>(in-package:morph)#<PACKAGE MORPH>
MORPH 3>(defun*fib(N)"Returns Nth Fibonacci number,where 0th is 0,1st is 1,and the rest are the sum of the previous two."(if(<=N1)N(+(fib(-N1))(fib(-N2)))))FIB
MORPH 4>(morph-measure-memoization′fib 19)41810.125MORPH 5>(morph-measure-memoization′fib 30)83204023.72MORPH 6>(morph-measure-memoization′fib 25)750252.141MORPH 7>(morph-measure-memoization′fib 27)1964185.594
这说明可以配置程序以测量可观测的执行事件，并且基于编程环境内的测量，动态推导在程序部分之间的可观测(相互)关系，例如调用方函数、被调用方函数、调用的数量、变量的使用等。显然，在上述例子中，最好使用FIB的可存储版本，这是因为对于所有调用，耗用的时间似乎更短，即(fib 19)0.125s，(fib 30)23.72s。
本发明的下一部分是能够控制代码修改的观测器O的功能性。
                   表14
CL-USER 8>(morph-fun-instance′fib)#<DEFUN-CLASS 206 A1B84>TMORPH 9>(memoized-logic(morph-fun-instance′fib))NILMORPH 10>(logic(morph-fun-instance′fib))(IF(<=N1)N(+(FIB(-N1))(FIB(-N2))))MORPH 11>(comments(morph-fun-instance′fib))"Returns Nth Fibonacci number,where 0th is 0,1st is 1,and the rest are the sum of the previous two."MORPH 12>(morph-memoize(morph-fun-instance′fib))FIB
显然，存在这样的实例：其具有gensym#<DEFUN-CLASS 206A1B84>，它承载了如由上述检查所说明的编程逻辑。其可以被命令以改变代码为存储版本。
                                   表15
MORPH 13>(memoized-logic(morph-fun-instance′fib))(LET   ((HASH-TABLE      (ECASE        HASH-TABLE-SOURCE   (:CREATE(MAKE-HASH-TABLE  :TEST    TEST))    (:DISK (LOAD-SAVED-MEMO-TABLENAME))(:OLD-FUNCTION  (GET FUNCTION-NAME      :MEMO-TABLE)))))(SETF(GET   NAME     :MEMO-TABLE)      HASH-TABLE)        (SETF     (GETNAME    :UNMEMOIZED-FUNCTION)      FUNCTION)         (SETF     (GETNAME :MEMO-TABLE-TEST) TEST) (PROCLAIM (SYSTEM::BQ-LIST (QUOTENOTINLINE)NAME))(DECLARE(OPTIMIZE(SPEED 3)(COMPILATION-SPEED0)(SPACE 0)(SAFETY 0)))(LET((HASH-KEY(FUNCALL KEY PARAMETERS)))(MULTIPLE-VALUE-BIND     (VALUE   FOUND?)  (GETHASH   HASH-KEYHASH-TABLE)   (COND      (FOUND?   (INCF  (THE   FIXNUM   (GETNAME  :HASH-TABLE-LOOKUPS)))  VALUE) (T (INCF (THE FIXNUM (GETNAME   :ORIGINAL-FUNCTION-CALLS)))  (SETF   (GETHASH  HASH-KEYHASH-TABLE)(IF(<=N 1)N(+(FIB(-N 1))(FIB(-N 2))))))))))MORPH 10>(morph-measure-memoization′fib 17)15970.0MORPH 11>(morph-measure-memoization′fib 19)41810.0MORPH 12>(morph-measure-memoization′fib 30)8320400.0
结果是现在当前版本的通常评估和存储版本之间的时差为0s。
编程语言上的每个FAQ包括代码改进建议的较大集合；存在许多关于代码优化和构建技术的书籍，例如参见在1993年8月的Lisp users andVendors conference出版的Peter Norvig和Kent Pitman的“Tutorial onGood LISP programming Style”中好的和不好的编程例子；这可以从http：//www.iiia.csic.es/～puyol/TAPIA/transpas/Norvig-luv-slides.pdf下载。
函数预留代码修改的例子例如是动态编程，即为了重新使用而存储函数结果。这需要多数情况下是统一的软件的数据部分适配。这意味着要存储的结果应当满足以下所有标准：函数的返回值不应该从调用到调用改变，函数不应具有副作用，并且函数不应使用易变的自变量(argument)。显然，存储每次调用时都会改变的函数是无用的。同样，不存储具有故意副作用的函数是重要的(以某种方式更新状态的函数-这是可观测的属性，并且可以由上述观测器技术来统计地检测)，这是因为针对后续调用不会重复副作用。存储具有易变自变量的函数是危险的，这是由于相同原因，即存储易变的类在散列表中是危险的。如果利用自变量调用存储函数一次，使自变量对象转变，则第二次调用函数，存储器可能将其看作是缓存命中(cache hit)并且不重新计算所述值。简言之，可能返回错误值。不幸的是，判断代码是否可以受益于存储的唯一方式是对它进行概要(profile)，即，令观测器确定函数是否可以存储。
通常(如上所示的)称作存储的这个技术，允许“记住”先前调用的函数，如果利用与先前执行完全相同的自变量而进行调用则返回先前计算的值(而不是重新计算)。“自动”存储是指现有函数可以被转换为存储函数，而无需针对函数自身进行代码中的任何改变。如果计算在程序执行的各个点上被重复，则这可以导致巨大的加速，同时仍对代码的用户保留一定程度的透明。至少存在四种存储的基本应用。函数调用内的重复：下面所说明的这个情况是当单个例程超过需要地调用一些子例程时(或递归地调用其本身)时，这导致额外的计算。通过存储，利用动态编程的效应，这些结果立即被返回用于后续的调用。实际上，所述第一种情况可以被认为是用于自动动态编程的工具，但是无需以正确的顺序构建子片段(sub-piece)。这通常会将指数算法的时间缩减至多项式或甚至线性时间。给定足够的考虑，这可以通过以下操作而无需自动存储便利(facility)地被解决：以适当顺序构建子片段，或维护专用本地数据结构以保留结果。自动进行所述操作的优势在于：如果已经测试了简单算法则需要较少的调试和测试，本发明允许运行时来回地改变，这更加透明，并且简单容易地使用。时间上的重复：第二种情况针对时间上重复的、但是从程序中的离散位置的函数的调用，或甚至当用户在交互式程序中重复地取消(revoke)时。这通常通过常数因子而产生了加速，但是所述因子可能较大。无需自动存储便利，仅有的可选方案是维护专用全局数据结构，这需要测试和调试，以及针对最多与存储一样有效的事情的许多额外工作。离线(off-line)运行：第三种情况是当函数太复杂，以致于执行离线计算并为稍后的会话保留结果需要一定的付出(pay-off)。自动存储便利提供了简单透明的方法来保留结果，并且在稍后的会话中将所述结果自动关联于函数。定时和概要：最后的情况是当在传统的性能概要和优化中将存储用作工具时。观测器可以提供某种度量(metering)系统，并且这可以用于主要测试实例。通过使用存储时间或利用存储，用户可以存储正讨论的例程，然后多次运行相同的测试实例。如果相同的测试实例在第二存储运行期间运行仅快了5％，则这表明正讨论的例程中没有存储会在测试实例的性能中产生多于5％的差异，并且这可能不是开始优化工作的位置。
存储仅对于作为真函数(true function)的例程有意义，而不是过程。即，输出必须完全由输入所确定，并且全局变量上不存在内在相关性，或其它副作用。如果存储函数返回稍后被破坏地修改的值，则随后期望初始值的调用替代地得到被修改值。例如，一种用于在列表上执行破坏操作(nconc，指定位置上的setf，sort等)的凭经验规则(rule of thumb)是，仅当列表是最近被构造(cons)时才是安全的：即，你可以保证为你提供列表的函数已经构建了它，并且因此它不与别处使用的列表共享结构。然而，如果构建列表的函数被存储，则不再重新构造所述列表，并且破坏操作可能导致发生问题。存储使用EQUAL来比较当前自变量列表与以前的列表。如果自变量列表包含一些条目，其中仅EQUALP可以识别两个不同对象具有相同的内部值，则可能产生不适当的重复。SAVE-MEMO-TABLE代码取决于具有READ可以再次解释的对象的打印表示。这对于列表、符号、数字和字符串是正确的，但是对于数组、散列表、CLOS实例等是不正确的。在一些所述情况下，可以定义客户打印函数，但是通常在可以在要保存到磁盘的存储函数中的值类型(输入或输出)上有所限制。
默认地使用EQUAL，通过在自变量列表上进行准确匹配来执行存储。类似地，当自变量是浮点数时一个人可以具有违反直觉的结果，例如忘记2不等于2.0，1.234567不等于1.23456等，即使你的函数可能等同地对待它们。在多数情况下，存储是时间和存储器的折衷。在极端情况下，其中频繁重复的函数生成了较大的结构，存储可能实际上节省了存储空间(没有无用信息)，但是在大多数情况下，牺牲空间以获得速度。应当仔细评估这些折衷，这通过使用观测器来了解函数实际重复的频率，WITH-MEMORIZATION和MEMORIZED-TIME(针对存储和未存储版本二者报告时间和空间)。幸运地，所有这些属性都是可观测的，例如通过简单地模拟存储和未存储的函数的测试实例集合。可以在例如Proceedings of the Sixth International Symposium on Artificial Intelligence中Marty Hall和James Mayfield的“Improving Performance of AISoftware”中找到有关存储的其它细节。
然而，将存储包装(memorizing wrapper)应用于现有代码十分容易，并且重要的是，这正如去除包装一样容易。这意味着以下简单的优化策略：(半)自动地选择作为存储候选的函数。添加存储包装到函数。观察函数(和整个系统)的行为。如果性能提升很小或没有性能提升，则去除存储包装。用新的(存储)代码(真正变形)来替代函数。理想地，由于仅可以确定添加是值得的，因此可以分析自动添加存储对整个系统的影响。一些方法即使本身计算上很复杂，也可能没有受益于被存储，例如简单地由于从来不超过一次地利用相同自变量调用所述方法。
通过应用所述技术，观测器例如可以触发所述宏的应用，如果存在许多重复计算的、复杂的、例如时间上复杂的函数调用。不像在上述代码片段中，执行能够动态适配自身以记住函数调用，不仅是统一的，即针对所有调用，而是取决于实际执行。
例如，假设如货币转换的简单应用，假设还有两个不同的用户配置，第一配置是商店中价格的重复转换。由于重复而存储所述价格集合以及所述转换。第二配置可能是旅行者的偶尔使用。在所述配置中，不太可能发生重复。因此几乎没有要存储的。针对更复杂的转换，例如速度识别器或用户接口的任何反应行为，类似的自变量支持不同使用配置的使用。通常，重复的输入序列可以通过应用所述方法来被存储，并且大大增加反应和处理速度。
另一个功能上不等同的十分简单的重构策略是动态代码减少。只要观测器识别到在很长的操作时间内没有调用方法，则可以移除这个操作的代码。结果是所述代码修改产生了更小的代码大小，以及更短的启动时间，代价是只要偶尔使用函数就要进行版次反向跟踪。动态识别并消除无用代码。应当指出，在创建阶段P1不能执行所述优化，这是因为针对任何执行，代码是无用的还是有效的是个不确定问题。
在实际应用情景中，软件清除未使用的组件，例如可以移除字处理器中长期未使用的专用格式化组件，而不会影响有效(实际使用)的功能性。
例如在William F.Opdyke的论文“Refactoring Object-orientedFrameworks”中，可以找到具有针对程序转换的自动应用和应用的指示的、保守的重构策略的较大集合。
硬编码的行为将为表达为高级目的的行为让步，例如“最大化这个有用(utility)函数”，或“发现著名的消息转换服务”。元素之中的硬布线(Hardwired)连接将为逐渐不直接的元素合作方的规范让步-从物理地址的规范到名称的规范，以及最终到函数的规范，其中合作方的身份仅在被需要时才被解决。硬布线关系将发展成通过协商建立的灵活关系。元素将无需人工干预地自动处理新的故障模式，例如提供商违反合同。
根据本发明的方法非常适用于面向服务的体系结构概念，例如web和grid服务或软件代理。通过将自主元素看作代理并且将自主系统看作多代理系统，应当清楚，面向代理的体系结构概念是非常重要的，这是因为可以交换功能性而不仅是调用或交互。在部署之后，在面向对象的环境中的典型的高度调用的web服务或对象可以例如有利地被自动集成或聚集。为了知道服务更新，可以增强观测器以检测集成代码和外部服务之间的功能分歧；优选地是静态的并且与实际使用同时进行。
自主元素具有复杂的生命周期，持续地进行多个活动线程，并且持续感知并响应它们所处的环境。与它们环境的自主、前摄及有意图的交互可以引导开发者，例如通过观察软件的两个部分之间的特定关系，并且利用它们的优点和缺点来自动建议重新构造的可选方案。
一旦检测到故障，可以遍及软件的所有实例来分配所述知识，并且通过代码修改来阻塞功能性。在必要的情况下，这种自主软件可以甚至请求作者进行更新或修补。
统计模型可以支持观测器的元编程知识，例如识别情景的上下文中哪些修改是有用的。通常，编程规则本身变得透明，这是计算机科学的新的方面。重新构造或高阶编程，即将函数用作值的能力，即作为其它函数的自变量的函数以及可以是其它函数的返回值的函数，很少被应用并且相当理论化。这个类型的编程大多用于功能性编程，但是其在“规律的”面向对象的编程中也非常有用，并且它在应用本发明时通过工程方法以自然的方式被支持时也非常有用。
综上所述，主要特征是充分深思熟虑的体系结构。围绕这个深思熟虑的结构而构建的显著特征将包括：功能性抽象的统一、基于来自能力所控制的明确协商的公理的正式证明的安全性、高阶函数、纹理细密的构成、分布式联网、正交持续的存储、容错计算、版本感知、动态代码重新生成、封装的高级模型，这优选地利用高度执行的动态编译集合。
具有演进的需求的每天改变的环境中普遍存在的计算，是一项技术挑战。应付它的已知技术是程序转换、解释和抽象(虚拟)机、编译技术、智能代理技术、演进的及动态的代数，以及高阶编程语言。
技术上来说，适配演进(改变)的环境的第一技术之一，是操作系统和无用信息收集器中的存储调度程序。它们使操作环境适配于静态程序资源的需要。
尽管发生程序演进，然而程序资源本身至今都被看作是静态固定的。开发阶段和执行阶段之间存在严格的距离。
即时(just in time)编译器技术和高阶编程语言环境，允许动态编译和优化。如LISP和ProLog的高级环境甚至支持执行时的代码修改。直到现在还不知道支持代码变形的控制实例。(系统的变形能力是指动态修改其运行时间的能力)。
代数概念“演进代数”(EA，Evolving Algebra)提供针对本发明的必要语义学基础。可以如下说明EA论点：可以通过合造的EA来在每个算法的自然抽象级别上模拟所述算法。演进代数方法的主要目的是提供简洁且可执行的算法的正式规范。
改变环境将在以后发生。已经知道结果：损坏的参考或链接、遗漏资源、不相容等等。由于多种变型，应用到当前系统中的静态代码产生了(在彻底的(完全的)需求覆盖的情况下)巨大的不易处理的软件包。当两个软件片段之间的交互接口改变时，所述软件丢失。由于相当静态的软件世界，当前方法可以应付改变的需求，但是其远不是理想的巧妙解决方案。
另外的解决方案是这样的系统：其中组件或部分被看作是自组织的单独实体，其重新构造由外部交互所激励的本身。系统包括可观测且演进的组件以改变自身。系统的一个重要部分是通过标识其上实现程序演进的“编程构建块”来定义可执行的语义。
建议的技术实现了可以“学习”的算法，并且通过比较它的动作的结果与要达到的目的而改变它的行为。算法是一个程序，其可以被写成一组步骤，用于从给定输入产生指定的输出。所建议的反馈控制是一种过程，机器或系统的输出或行为通过该过程来改变其操作，以持续减少输出和目标值之差。变形软件个体，即基于结构动态修改其运行时间的能力(或就代理通信系统而言，代理的责任)，是定义软件系统的框架，所述软件系统能够在解释的程序语言的级别上自修改并重新产生。
抽象地说，自修改系统包括观测器实例、演进历史和当前图像(image)，其中观测器能够检查动态方面，如运行的、历史的软件部分之间的交互，即如版次或版本的演进快照(snap shot)的收集，并且图像是(现行)运行时间。所述系统中的计算导致可观测的事件并触发了图像的修改。
为了说明所述方法的动态，下面描述了一组使用实例。假设对象系统环境包含用于持续的对象历史的面向对象的数据库基本管理系统，即冻结实例，以及图像内的现行实例。对象，即如变量、方法、类、实例、关系、消息、聚集等，具有属性。观测器检测到当执行更新这些属性时所发生的特定事件所导致的结果。所述系统也包括到外界的接口，其中(可观测的)与系统边界的交互发生，并且将变得可观测-激励了反应行为。
进一步假设类的对象实例的系统，其包括类和实例变量、具有选择、判决、迭代、递归(方法调用)和其它通常的面向对象的构造的类方法和实例方法。持续在可操作状态更新属性的观测器观测这些构造中的每一个，所述属性例如通过变量属性而被说明该变量属性例如是访问数目、访问实例、或更新(修改)数目等。
事件(存储于属性中)的模式可以触发修改，如将对于所有实例通用的实例变量迁移到类变量中，或将全局变量迁移到实例或类变量中，或交换类(包含相关性)之间的槽等。
由于分布式(复杂)系统的组件中甚至较小的结构改变会导致不可预见的系统行为，因此建议逐步增长的小的改进。演进历史可以用来以自动方式执行衰退测试，以增加对程序转换历史正确性的信心。
存在一组探索法的改进，例如丢弃几乎不使用的代码段，或聚集类或对象关系。此外，存在从编译技术所知的多组(保守的)程序转换。在(探索法)修改之前，环境可能冻结图像的演进状态以实现后向跟踪。
所述技术能够在个体中累积执行知识，所述个体如组件、实例或代理。例如，如果仅代理B经常使用(在运行时刻)代理A的特定行为，则代理A决定通过添加涉及的方法以及方案(类)到代理B，来将所述行为移至代理B。反之亦然，代理C可能需要代理A的第一能力，而代理B需要代理A的第二能力。观测器从统计观测识别情况，并且触发A划分为A1和A2；在该划分之后，这些部分被融入代理B和C中。
图5中示出了所述情景，示出了软件S1、S2的演进历史H。软件S1、S2被示为多边形的三角形，其中三角形是软件的模型组件C、C’。多边形可以被看作是软件的边界。历史开始于初始演进软件S1，除了其它组件C，该软件S1包括改进组件IC。假设可观测的属性是三角形的协调性，其中区域是一种针对组件的某种(可测量的)复杂度的测量，如耗用时间。在软件S2的演进版本中，三角形似乎更为谐调，即组件被变形为一种改进的配置/分布/安排。
本发明实现了方法(函数)行为的优化和重组织的智能且自动的应用，如存储器(通用缓存包装)。它们的先决条件是不应当从调用到调用改变方法的返回值并且所述方法不应具有副作用。所述方法不应采用易变的自变量。有效的缓存包装大大地增强了反应性。另一个重组织是(动态)部分评估。部分评估创建了通用程序的专用版本。专用程序可能更有效并且比通用版本运行更快。令P是程序，其采用两个输入D1和D2。通常，在一个步骤中评估P对(D1，D2)的应用：用输入(D1，D2)评估P以产生结果res。然而，可选地，它可以根据Curry-Howard(柯里-霍华德)同构在两个步骤中被评估：首先用输入D1部分评估P，其产生新的程序R，即P的参数化版本。然后，用输入D2评估R以产生结果。程序R是P的专用版本(针对第一输入的特定值D1)，并且称为剩余(residual)程序。产生R的过程称为部分评估，或程序专用化。部分评估的一个优势在于执行速度：专用程序R通常相比通用程序P更快，另一个优势在于接口效率和聚集的简化。
实现变形代理，必须使用支持动态的面向对象的编程的编程语言，其通过提供强大的元对象协议而包括在运行时间改变程序(类)和结构的能力。动态的面向对象的编程是一种软件开发技术，其实现了在开发期间且在部署之后调整应用而无需访问源代码。建议的环境因此包括动态对象(运行时间改变＝演进)、对象持续(存储/检索对象结构和方法＝版本化)、(交互的)代码操纵(逐渐增加的change-eval/compile-run循环)，建议了元对象协议(关于对象的反映/推理)。
对照程序合成(从描述产生程序的宏步骤)，本发明处理“代码演进的环境”的两级结构(通过演进增强程序的微步骤)。第1级：称作“环境”，其负责：观测个体(程序构造)、微改变的个体(程序转换)，度量行为(统计以及探索法)、学习新规则、更新规则、对象库(＝知识)更新或推断(例如编程)源更新(具有产生的评论)事件、知识库等。
第2层：称作“目标程序”(要开发的软件的当前版本)。所述目标具有如包、类、实例等的组件，下至每个程序构造，其中每个所述构造具有环境中的“模型”。所述模型以及修改、观测规则，使得环境能够建议演进步骤。下面是概念/方法/条件的列表，其导致(半自动)程序修改。
如果系统判定可以通过更有效地重新构造参与个体(实例、代理)的知识来改进任务性能，则个体本身可以执行重新构造。
由于分布式(复杂)系统的组件中小的结构改变会导致不可预见的系统行为，建议了逐渐增加的小的改进。
自主程序操纵的概念大规模地(in the large)允许全面影响程序的操纵，而不仅是本地上在一个模块中。两个大规模的例子是模块间重命名和重组织。为了找到引导重组织已知(静态)软件的应用的使用的标准，建议了度量。所述度量可以基于词汇隐匿和测量过度可见性的原理。存在越大的过度可见性，即没有使用的可见项越多，度量值就越小。发展静态软件度量的数量以增加软件质量。这些度量用作较差结构的项目部分的好的指示符。

Claims (12)

1.一种用于使计算机程序自动适配于环境的方法，所述计算机程序产品包括可执行部分和数据部分，所述方法包括以下步骤：针对环境配置所述计算机程序产品，并且在该环境中执行软件，其中，所述方法还包括以下步骤：观测执行的效果，即度量所述可执行部分的行为；利用所述软件分析被观测效果的相互关系；并且基于规则修改可执行部分以减小如低效或故障的不期望的被观测效果。
2.根据权利要求1的方法，还包括配置和改变管理，即代码部分持续的修改或状态。
3.根据权利要求1的方法，其中，所述被观测效果是无用代码的检测，并且所述修改包括被标识无用代码的消除。
4.根据权利要求1的方法，其中，所述被观测效果是两个部分之间紧密关系的检测，并且所述修改包括将所述两个部分重新构造在一起，例如将交互对象置于相同组件中、聚集外来调用方法、将变量置于合适的范围中等。
5.根据权利要求1的方法，其中，所述被观测效果是重复行为，并且所述修改包括添加对该重复行为的存储。
6.根据权利要求1的方法，其中，所述被观测效果是部分评估，并且所述修改包括柯里-霍华德态射的应用，即针对每个x存在更有效的f_x，其中f(x，y)＝f_x(y)。
7.根据权利要求1的方法，其中，当执行所述软件时，执行所述观测、分析和适配，其中优选地在背景中执行所述适配。
8.根据权利要求2的方法，其中，关于不期望的效果和功能等价，将先前版本与当前版本进行比较。
9.一种自动适配于环境的计算机程序产品，所述计算机程序产品包括可执行部分和数据部分，所述计算机程序产品包括配置装置，该配置装置用于针对环境而配置所述计算机程序产品，以在该环境中执行该计算机程序产品，其中，所述计算机程序产品包括观测装置，其用于观测所述执行的效果，即所述可执行部分的行为；推断装置，其用于利用所述计算机程序产品来分析被观测效果的相互关系；以及重新构造装置，其基于规则修改可执行部分以减小如低效或故障的不期望的效果。
10.根据权利要求9的计算机程序产品，还包括实现根据权利要求1到7中任一个的方法的编程装置。
11.一种用于制造根据权利要求9的自动适配的计算机程序产品的方法，其中，所述方法包括以下步骤：通过集成观测装置来配置所述可执行部分，其中该观测装置用于观测所述可执行部分的执行效果，即行为；通过用于利用所述软件分析被观测效果的相互关系的推断装置来配置所述可执行部分；并且通过用于基于规则修改可执行部分以减小不期望的效果的重新构造装置来配置所述可执行部分。
12.根据权利要求11的方法，其中，将所述观测、分析和/或适配通知给开发者。
CNB2006101014454A 2005-07-19 2006-07-13 使计算机程序产品自动适配于环境的方法和设备 Expired - Fee Related CN100511133C (zh)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
EP05106615A EP1752874A1 (en) 2005-07-19 2005-07-19 Adaptive evolutionary computer software product
EP05106615.7 2005-07-19

Publications (2)

Publication Number Publication Date
CN1900907A true CN1900907A (zh) 2007-01-24
CN100511133C CN100511133C (zh) 2009-07-08

Family

ID=35759220

Family Applications (1)

Application Number Title Priority Date Filing Date
CNB2006101014454A Expired - Fee Related CN100511133C (zh) 2005-07-19 2006-07-13 使计算机程序产品自动适配于环境的方法和设备

Country Status (3)

Country Link
US (1) US8418137B2 (zh)
EP (1) EP1752874A1 (zh)
CN (1) CN100511133C (zh)

Cited By (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN101315601B (zh) * 2007-06-01 2012-07-04 国际商业机器公司 用于管理资源的系统和方法
CN102662661A (zh) * 2012-03-23 2012-09-12 中山大学 一种面向嵌入式软件的软件分析集成方法

Families Citing this family (33)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CA2490645A1 (en) * 2004-12-16 2006-06-16 Ibm Canada Limited - Ibm Canada Limitee Data-centric distributed computing
US8261344B2 (en) 2006-06-30 2012-09-04 Sophos Plc Method and system for classification of software using characteristics and combinations of such characteristics
US8365286B2 (en) * 2006-06-30 2013-01-29 Sophos Plc Method and system for classification of software using characteristics and combinations of such characteristics
US8108848B2 (en) * 2007-08-15 2012-01-31 Microsoft Corporation Automatic and transparent memoization
CA2607537A1 (en) * 2007-10-22 2009-04-22 Ibm Canada Limited - Ibm Canada Limitee Software engineering system and method for self-adaptive dynamic software components
US20090112932A1 (en) * 2007-10-26 2009-04-30 Microsoft Corporation Visualizing key performance indicators for model-based applications
US8181155B2 (en) * 2008-02-29 2012-05-15 Microsoft Corporation Unified expression and location framework
WO2009108943A2 (en) * 2008-02-29 2009-09-03 Doyenz Incorporated Automation for virtualized it environments
US7991880B2 (en) * 2008-03-31 2011-08-02 Nokia Corporation Bionets architecture for building services capable of self-evolution
US8689171B2 (en) * 2008-04-21 2014-04-01 International Business Machines Corporation System and method for managing resources using a compositional programming model
US8195692B2 (en) * 2008-12-11 2012-06-05 International Business Machines Corporation System and method for managing semantic and syntactic metadata
US9117071B2 (en) 2009-06-03 2015-08-25 Apple Inc. Methods and apparatuses for secure compilation
US8677329B2 (en) * 2009-06-03 2014-03-18 Apple Inc. Methods and apparatuses for a compiler server
US8484453B2 (en) 2010-05-25 2013-07-09 Freescale Semiconductor, Inc. Data processing system having an operating system adapter and method
US9424010B2 (en) * 2010-08-30 2016-08-23 International Business Machines Corporation Extraction of functional semantics and isolated dataflow from imperative object oriented languages
US8918776B2 (en) 2011-08-24 2014-12-23 Microsoft Corporation Self-adapting software system
US9262416B2 (en) 2012-11-08 2016-02-16 Microsoft Technology Licensing, Llc Purity analysis using white list/black list analysis
US8752021B2 (en) * 2012-11-08 2014-06-10 Concurix Corporation Input vector analysis for memoization estimation
US9104432B2 (en) 2013-06-24 2015-08-11 International Business Machines Corporation Extracting stream graph structure in a computer language by pre-executing a deterministic subset
US10108402B2 (en) * 2014-01-30 2018-10-23 Hewlett Packard Enterprise Development Lp Persistent pointers for programs running on NVRAM based computers
US9727318B2 (en) 2014-02-18 2017-08-08 Facebook, Inc. Techniques to identify and purge unused code
US9588760B1 (en) * 2015-11-24 2017-03-07 International Business Machines Corporation Software application development feature and defect selection
US10565089B2 (en) * 2016-08-15 2020-02-18 Sap Se Identification of code features potentially associated with code behavior
US10042613B2 (en) * 2016-08-19 2018-08-07 International Business Machines Corporation System, method, and recording medium for validating computer documentation
US10467195B2 (en) 2016-09-06 2019-11-05 Samsung Electronics Co., Ltd. Adaptive caching replacement manager with dynamic updating granulates and partitions for shared flash-based storage system
US10455045B2 (en) 2016-09-06 2019-10-22 Samsung Electronics Co., Ltd. Automatic data replica manager in distributed caching and data processing systems
US10528479B2 (en) * 2017-06-02 2020-01-07 Huawei Technologies Co., Ltd. Global variable migration via virtual memory overlay technique for multi-version asynchronous dynamic software update
US10482005B1 (en) 2017-09-26 2019-11-19 EMC IP Holding Company LLC Method and apparatus for developer code risk assessment
US10481879B2 (en) * 2018-02-07 2019-11-19 Microsoft Technology Licensing, Llc Code development using continued machine learnings
US10710239B2 (en) * 2018-11-08 2020-07-14 Bank Of America Corporation Intelligent control code update for robotic process automation
CN110362301B (zh) * 2019-06-10 2021-04-09 北京大学 一种终端应用行为反射的处理方法
US11907875B2 (en) 2019-11-06 2024-02-20 International Business Machines Corporation Collaborative development
US11093238B2 (en) * 2019-11-06 2021-08-17 International Business Machines Corporation Collaborative software development

Family Cites Families (13)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CA2002201C (en) * 1988-12-06 1999-04-27 John Charles Goettelmann Translation technique
US5842017A (en) * 1996-01-29 1998-11-24 Digital Equipment Corporation Method and apparatus for forming a translation unit
US5832205A (en) * 1996-08-20 1998-11-03 Transmeta Corporation Memory controller for a microprocessor for detecting a failure of speculation on the physical nature of a component being addressed
GB9825102D0 (en) * 1998-11-16 1999-01-13 Insignia Solutions Plc Computer system
US6378066B1 (en) * 1999-02-04 2002-04-23 Sun Microsystems, Inc. Method, apparatus, and article of manufacture for developing and executing data flow programs, and optimizing user input specifications
US6470492B2 (en) * 1999-05-14 2002-10-22 Hewlett-Packard Company Low overhead speculative selection of hot traces in a caching dynamic translator
US7032227B2 (en) * 2000-08-14 2006-04-18 Twin Communications Of America, Inc. Portable operating environment for information devices
US7162715B1 (en) * 2002-03-16 2007-01-09 I-Squared, Inc. Method and apparatus for preemptive monitoring of software binaries by instruction interception and dynamic recompilation
US7272824B2 (en) * 2003-03-06 2007-09-18 International Business Machines Corporation Method for runtime determination of available input argument types for a software program
GB2400937B (en) * 2003-04-22 2005-05-18 Transitive Ltd Method and apparatus for performing interpreter optimizations during program code conversion
JP2005173788A (ja) * 2003-12-09 2005-06-30 Ibm Japan Ltd オートノミック・コンピューティングシステム、実行環境制御方法及びプログラム
US7487494B2 (en) * 2004-08-02 2009-02-03 International Business Machines Corporation Approach to monitor application states for self-managing systems
US8615743B2 (en) * 2006-02-27 2013-12-24 Microsoft Corporation Adaptive compiled code

Cited By (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN101315601B (zh) * 2007-06-01 2012-07-04 国际商业机器公司 用于管理资源的系统和方法
CN102662661A (zh) * 2012-03-23 2012-09-12 中山大学 一种面向嵌入式软件的软件分析集成方法
CN102662661B (zh) * 2012-03-23 2015-09-09 中山大学 一种面向嵌入式软件的软件分析集成方法

Also Published As

Publication number Publication date
US20070033659A1 (en) 2007-02-08
EP1752874A1 (en) 2007-02-14
CN100511133C (zh) 2009-07-08
US8418137B2 (en) 2013-04-09

Similar Documents

Publication Publication Date Title
CN100511133C (zh) 使计算机程序产品自动适配于环境的方法和设备
Kaliszyk et al. Holstep: A machine learning dataset for higher-order logic theorem proving
Bowers et al. Top-down synthesis for library learning
Bornholt et al. Synthesizing memory models from framework sketches and litmus tests
Zheng et al. AStitch: enabling a new multi-dimensional optimization space for memory-intensive ML training and inference on modern SIMT architectures
US9542176B2 (en) Predicting software build errors
Koschke Survey of research on software clones
Balci Requirements for model development environments
Ramamoorthy et al. Programming in the Large
Li et al. Discovery of potential parallelism in sequential programs
CN102187313A (zh) 高速缓存运行时生成的代码
Riedl-Ehrenleitner et al. Towards model-and-code consistency checking
Long et al. Adaptive java optimisation using instance-based learning
Singher et al. Theory exploration powered by deductive synthesis
Börger et al. On formalizing UML state machines using ASMs
Vasilache et al. Automatic correction of loop transformations
Selva et al. Building a polyhedral representation from an instrumented execution: Making dynamic analyses of nonaffine programs scalable
Streit et al. Sambamba: runtime adaptive parallel execution
Singh et al. EB2ALL: an automatic code generation tool
Margaria et al. Leveraging Applications of Formal Methods, Verification and Validation. Technologies for Mastering Change: 6th International Symposium, ISoLA 2014, Imperial, Corfu, Greece, October 8-11, 2014, Proceedings, Part I
Broll et al. Deepforge: An open source, collaborative environment for reproducible deep learning
Tian et al. Towards framework-independent, non-intrusive performance characterization for dataflow computation
Anand Application of ETL tools in business intelligence
Gruber et al. Building of a Polyhedral Representation from an Instrumented Execution: Making Dynamic Analyses of non-Affine Programs Scalable
Serttaş et al. PBench: A Parallel, Real-Time Benchmark Suite

Legal Events

Date Code Title Description
C06 Publication
PB01 Publication
C10 Entry into substantive examination
SE01 Entry into force of request for substantive examination
C14 Grant of patent or utility model
GR01 Patent grant
CF01 Termination of patent right due to non-payment of annual fee
CF01 Termination of patent right due to non-payment of annual fee

Granted publication date: 20090708

Termination date: 20160713