下载文档原格式
孟德尔随机化graphical abstract -回复“孟德尔随机化”是一种用于实验证明因果推断的方法，对于研究者来说非常重要。
本文将分为几个步骤来回答关于孟德尔随机化的问题。
第一步：介绍什么是孟德尔随机化孟德尔随机化是一种实验设计的方法，旨在减少实验中可能引起结果偏差的因素。
在这种方法中，研究者将实验对象（如实验组和对照组）分配到不同的组中，以确保每个组中的特定特征和变量在统计上是相似的。
第二步：解释孟德尔随机化方法是如何工作的孟德尔随机化的核心思想是以最小的偏差随机地将实验对象分配到不同的组中。
这可以通过以下步骤来实现：1. 首先，研究者要确定实验对象的总体特征和变量。
2. 然后，研究者使用随机数表或计算机生成的随机数字，将实验对象分配到不同的组中。
3. 分配过程必须是完全随机的，以确保每个组中的特征和变量在统计上是相似的。
第三步：探讨为什么孟德尔随机化对因果推断非常重要孟德尔随机化是因果推断的关键步骤之一，因为它可以减少实验中其他因素的影响，从而更好地确定因果关系。
通过使用孟德尔随机化，研究者可以排除实验中可能引起结果偏差的潜在因素，如个体差异、背景因素等。
第四步：解释孟德尔随机化的优点和局限性孟德尔随机化的优点包括：1. 可以减少实验结果的偏差，提高结果的可靠性。
2. 可以确保实验组和对照组在统计意义上是相似的，从而更好地进行对比分析和因果推断。
3. 可以帮助研究者控制实验过程中可能产生的潜在干扰因素。
然而，孟德尔随机化也存在一些局限性：1. 随机分配并不能消除所有的潜在干扰因素，只能减少偏差的概率。
2. 孟德尔随机化在某些特定情况下可能存在困难，例如当实验对象数量较少时。
3. 在实践中，实验可能面临一些实施上的困难，如随机化过程的实施和监督等。
第五步：总结孟德尔随机化的应用领域和重要性孟德尔随机化广泛应用于医学研究、社会科学研究和教育研究等领域。
它在这些领域中的应用对于确立因果关系、评估政策效果以及改进实践非常重要。
长期完整性的分层容错论文翻译长期完整性的分层容错秉健春，佩特罗斯曼尼阿蒂斯英特尔研究大学伯克利分校斯科特 Shenker，约翰 Kubiatowicz 美国加州大学伯克利分校摘要通常，容错服务有关的假设类型和故障，他们可以容忍的最大数量这种故障时，同时提供其正确性的保证;阈值是侵犯性，正确性丢失。
我们重新审视的概念在长期归档存储方面的故障阈值。
我们注意到，故障阈值不可避免地长期违反服务，使得传统的容错不适用长期的。
在这项工作中，我们进行的再分配容错预算的一项长期的服务。
我们分裂投入服务件的服务，每一个都可以容忍不同没有失败的故障数（并不会造成整个服务失败）：每件可在一个关键值得信赖的过错层，它必须永远不会失败，或不可信的故障层，它可以大量经常失败，或其他故障层次之间。
通过仔细工程的一项长期的服务分裂成片，必须服从不同的故障阈值，我们可以延长其必然灭亡。
我们证明了这一点做法 Bonafide，一个长期的 key - value 存储，与所有类似的文献中提出的系统，在保持完整性面对拜占庭故障，无需自我认证的数据。
我们描述了分层容错的概念，设计，实施， Bonafide 和实验1/ 3评价，并主张我们的做法是一个实际仍未显著改善在长期服务的艺术状态。
一，引言当前容错复制服务设计往往不适合长期的应用，如档案，数字文物，这是越来越重要的存储 [42]，为企业的监管[5， 6]，文化[36]原因。
从典型的故障假设这不合适结果这类系统的正确性空调。
例如，在典型的拜占庭容错（BFT）系统[13]，它是假定复制故障副本的数目总是比一些不太固定阈值，如副本人口的 1 / 3。
在典型的短期的应用，这样一个 uniformthreshold 基于故障假设是合理的，可以实现的。
例如，可以说在一个 wellmaintained 人口多元化，高保证副本服务器，由当时总人口的三分之一被打破生长进入或刚刚出现故障，故障副本的运营商可以修复它们。
JVM for a Heterogeneous Shared Memory SystemDeQing Chen,Chunqiang Tang,Sandhya Dwarkadas,and Michael L.ScottComputer Science Department,University of Rochester AbstractInterWeave is a middleware system that supports the shar-ing of strongly typed data structures across heterogeneouslanguages and machine architectures.Java presents spe-cial challenges for InterWeave,including write detection,data translation,and the interface with the garbage col-lector.In this paper,we discuss our implementation ofJ-InterWeave,a JVM based on the Kaffe virtual machineand on our locally developed InterWeave client software.J-InterWeave uses bytecode instrumentation to detectwrites to shared objects,and leverages Kaffe’s class ob-jects to generate type information for correct transla-tion between the local object format and the machine-independent InterWeave wire format.Experiments in-dicate that our bytecode instrumentation imposes lessthan2%performance cost in Kaffe interpretation mode,and less than10%overhead in JIT mode.Moreover,J-InterWeave’s translation between local and wire format ismore than8times as fast as the implementation of ob-ject serialization in Sun JDK1.3.1for double arrays.Toillustrate theflexibility and efficiency of J-InterWeave inpractice,we discuss its use for remote visualization andsteering of a stellar dynamics simulation system writtenin C.1IntroductionMany recent projects have sought to support distributedshared memory in Java[3,16,24,32,38,41].Manyof these projects seek to enhance Java’s usefulness forlarge-scale parallel programs,and thus to compete withmore traditional languages such as C and Fortran in thearea of scientific computing.All assume that applicationcode will be written entirely in Java.Many—particularlythose based on existing software distributed shared mem-ory(S-DSM)systems—assume that all code will run oninstances of a common JVM.has yet to displace Fortran for scientific computing sug-gests that Java will be unlikely to do so soon.Even for systems written entirely in Java,it is appealing to be able to share objects across heterogeneous JVMs. This is possible,of course,using RMI and object serial-ization,but the resulting performance is poor[6].The ability to share state across different languages and heterogeneous platforms can also help build scalable dis-tributed services in general.Previous research on var-ious RPC(remote procedure call)systems[21,29]in-dicate that caching at the client side is an efficient way to improve service scalability.However,in those sys-tems,caching is mostly implemented in an ad-hoc man-ner,lacking a generalized translation semantics and co-herence model.Our on-going research project,InterWeave[9,37],aims to facilitate state sharing among distributed programs written in multiple languages(Java among them)and run-ning on heterogeneous machine architectures.InterWeave applications share strongly-typed data structures located in InterWeave segments.Data in a segment is defined using a machine and platform-independent interface de-scription language(IDL),and can be mapped into the ap-plication’s local memory assuming proper InterWeave li-brary calls.Once mapped,the data can be accessed as ordinary local objects.In this paper,we focus on the implementation of In-terWeave support in a Java Virtual Machine.We call our system J-InterWeave.The implementation is based on an existing implementation of InterWeave for C,and on the Kaffe virtual machine,version1.0.6[27].Our decision to implement InterWeave support directly in the JVM clearly reduces the generality of our work.A more portable approach would implement InterWeave support for segment management and wire-format trans-lation in Java libraries.This portability would come,how-ever,at what we consider an unacceptable price in perfor-mance.Because InterWeave employs a clearly defined internal wire format and communication protocol,it is at least possible in principle for support to be incorporated into other JVMs.We review related work in Java distributed shared state in Section2and provide a brief overview of the Inter-Weave system in Section3.A more detailed description is available elsewhere[8,37].Section4describes the J-InterWeave implementation.Section5presents the results of performance experiments,and describes the use of J-InterWeave for remote visualization and steering.Sec-tion6summarizes our results and suggests topics for fu-ture research.2Related WorkMany recent projects have sought to provide distributed data sharing in Java,either by building customized JVMs[2,3,24,38,41];by using pure Java implementa-tions(some of them with compiler support)[10,16,32]; or by using Java RMI[7,10,15,28].However,in all of these projects,sharing is limited to Java applications. To communicate with applications on heterogeneous plat-forms,today’s Java programmers can use network sock-ets,files,or RPC-like systems such as CORBA[39].What they lack is a general solution for distributed shared state. Breg and Polychronopoulos[6]have developed an al-ternative object serialization implementation in native code,which they show to be as much as eight times faster than the standard implementation.The direct compari-son between their results and ours is difficult.Our exper-iments suggest that J-Interweave is at least equally fast in the worst case scenario,in which an entire object is mod-ified.In cases where only part of an object is modified, InterWeave’s translation cost and communication band-width scale down proportionally,and can be expected to produce a significant performance advantage.Jaguar[40]modifies the JVM’s JIT(just-in-time com-piler)to map certain bytecode sequences directly to na-tive machine codes and shows that such bytecode rewrit-ing can improve the performance of object serialization. However the benefit is limited to certain types of objects and comes with an increasing price for accessing object fields.MOSS[12]facilitates the monitoring and steering of scientific applications with a CORBA-based distributed object system.InterWeave instead allows an application and its steerer to share their common state directly,and in-tegrates that sharing with the more tightly coupled sharing available in SMP clusters.Platform and language heterogeneity can be supported on virtual machine-based systems such as Sun JVM[23] and [25].The Common Language Run-time[20](CLR)under framework promises sup-port for multi-language application development.In com-parison to CLR,InterWeave’s goal is relatively modest: we map strongly typed state across languages.CLR seeks to map all high-level language features to a common type system and intermediate language,which in turn implies more semantic compromises for specific languages than are required with InterWeave.The transfer of abstract data structures wasfirst pro-posed by Herlihy and Liskov[17].Shasta[31]rewrites bi-nary code with instrumentation for access checks forfine-grained S-DSM.Midway[4]relies on compiler support to instrument writes to shared data items,much as we do in the J-InterWeave JVM.Various software shared memory systems[4,19,30]have been designed to explicitly asso-ciate synchronization operations with the shared data they protect in order to reduce coherence costs.Mermaid[42] and Agora[5]support data sharing across heterogeneous platforms,but only for restricted data types.3InterWeave OverviewIn this section,we provide a brief introduction to the design and implementation of InterWeave.A more de-tailed description can be found in an earlier paper[8]. For programs written in C,InterWeave is currently avail-able on a variety of Unix platforms and on Windows NT. J-InterWeave is a compatible implementation of the In-terWeave programming model,built on the Kaffe JVM. J-InterWeave allows a Java program to share data across heterogeneous architectures,and with programs in C and Fortran.The InterWeave programming model assumes a dis-tributed collection of servers and clients.Servers maintain persistent copies of InterWeave segments,and coordinate sharing of those segments by clients.To avail themselves of this support,clients must be linked with a special In-terWeave library,which serves to map a cached copy of needed segments into local memory.The servers are the same regardless of the programming language used by clients,but the client libraries may be different for differ-ent programming languages.In this paper we will focus on the client side.In the subsections below we describe the application programming interface for InterWeave programs written in Java.3.1Data Allocation and AddressingThe unit of sharing in InterWeave is a self-descriptive data segment within which programs allocate strongly typed blocks of memory.A block is a contiguous section of memory allocated in a segment.Every segment is specified by an Internet URL and managed by an InterWeave server running at the host indi-cated in the URL.Different segments may be managed by different servers.The blocks within a segment are num-bered and optionally named.By concatenating the seg-ment URL with a block number/name and offset(delim-ited by pound signs),we obtain a machine-independent pointer(MIP):“/path#block#offset”. To create and initialize a segment in Java,one can ex-ecute the following calls,each of which is elaborated on below or in the following subsections:IWSegment seg=new IWSegment(url);seg.wl_acquire();MyType myobj=new MyType(seg,blkname);myobj.field=......seg.wl_release();In Java,an InterWeave segment is captured as an IWSegment object.Assuming appropriate access rights, the new operation of the IWSegment object communi-cates with the appropriate server to initialize an empty segment.Blocks are allocated and modified after acquir-ing a write lock on the segment,described in more detail in Section3.3.The IWSegment object returned can be passed to the constructor of a particular block class to al-locate a block of that particular type in the segment. Once a segment is initialized,a process can convert be-tween the MIP of a particular data item in the segment and its local pointer by using mip ptr and ptr mip where appropriate.It should be emphasized that mip ptr is primar-ily a bootstrapping mechanism.Once a process has one pointer into a data structure(e.g.the root pointer in a lat-tice structure),any data reachable from that pointer can be directly accessed in the same way as local data,even if embedded pointers refer to data in other segments.In-terWeave’s pointer-swizzling and data-conversion mech-anisms ensure that such pointers will be valid local ma-chine addresses or references.It remains the program-mer’s responsibility to ensure that segments are accessed only under the protection of reader-writer locks.3.2HeterogeneityTo accommodate a variety of machine architectures,In-terWeave requires the programmer to use a language-and machine-independent notation(specifically,Sun’s XDR[36])to describe the data types inside an InterWeave segment.The InterWeave XDR compiler then translates this notation into type declarations and descriptors appro-priate to a particular programming language.When pro-gramming in C,the InterWeave XDR compiler generates twofiles:a.hfile containing type declarations and a.c file containing type descriptors.For Java,we generate a set of Java class declarationfiles.The type declarations generated by the XDR compiler are used by the programmer when writing the application. The type descriptors allow the InterWeave library to un-derstand the structure of types and to translate correctly between local and wire-format representations.The lo-cal representation is whatever the compiler normally em-ploys.In C,it takes the form of a pre-initialized data struc-ture;in Java,it is a class object.3.2.1Type Descriptors for JavaA special challenge in implementing Java for InterWeave is that the InterWeave XDR compiler needs to gener-ate correct type descriptors and ensure a one-to-one cor-respondence between the generated Java classes and C structures.In many cases mappings are straight forward: an XDR struct is mapped to a class in Java and a struct in C,primitivefields to primitivefields both in Java andC,pointersfields to object references in Java and pointers in C,and primitive arrays to primitive arrays. However,certain“semantics gaps”between Java and C force us to make some compromises.For example,a C pointer can point to any place inside a data block;while Java prohibits such liberties for any object reference. Thus,in our current design,we make the following compromises:An InterWeave block of a single primitive data item is translated into the corresponding wrapped class for the primitive type in Java(such as Integer,Float, etc.).Embedded structfields in an XDR struct definition areflattened out in Java and mapped asfields in its parent class.In C,they are translated naturally into embeddedfields.Array types are mapped into a wrapped IWObject(including the IWacquire,wl acquire, and rlpublic class IWSegment{public IWSegment(String URL,Boolean iscreate);public native staticint RegisterClass(Class type);public native staticObject mip_to_ptr(String mip);public native staticString ptr_to_mip(IWObject Ob-ject obj);......public native int wl_acquire();public native int wl_release();public native int rl_acquire();public native int rl_release();......}Figure2:IWSegment Class4.1.1JNI Library for IWSegment ClassThe native library for the IWSegment class serves as an intermediary between Kaffe and the C InterWeave library. Programmer-visible objects that reside within the IWSeg-ment library are managed in such a way that they look like ordinary Java objects.As in any JNI implementation,each native method has a corresponding C function that implements its function-ality.Most of these C functions simply translate their pa-rameters into C format and call corresponding functions in the C InterWeave API.However,the creation of an In-terWeave object and the method RegisterClass need special explanation.Mapping Blocks to Java Objects Like ordinary Java objects,InterWeave objects in Java are created by“new”operators.In Kaffe,the“new”operator is implemented directly by the bytecode execution engine.We modi-fied this implementation to call an internal function new-Block in the JNI library and newBlock calls the Inter-Weave C library to allocate an InterWeave block from the segment heap instead of the Kaffe object heap.Before returning the allocated block back to the“new”operator, newBlock initializes the block to be manipulated cor-rectly by Kaffe.In Kaffe,each Java object allocated from the Kaffe heap has an object header.This header contains a pointer to the object class and a pointer to its own monitor.Since C InterWeave already assumes that every block has a header (it makes no assumption about the contiguity of separate blocks),we put the Kaffe header at the beginning of what C InterWeave considers the body of the block.A correctly initialized J-InterWeave object is shown in Figure3.Figure3:Block structure in J-InterWeaveAfter returning from newBlock,the Kaffe engine calls the class constructor and executes any user cus-tomized operations.Java Class to C Type Descriptor Before any use of a class in a J-InterWeave segment,including the creation of an InterWeave object of the type,the class object must befirst registered with RegisterClass.Register-Class uses the reflection mechanism provided by the Java runtime system to determine the following informa-tion needed to generate the C type descriptor and passes it to the registration function in the C library.1.type of the block,whether it is a structure,array orpointer.2.total size of the block.3.for structures,the number offields,eachfield’s off-set in the structure,and a pointer to eachfield’s type descriptor.4.for arrays,the number of elements and a pointer tothe element’s type descriptor.5.for pointers,a type descriptor for the pointed-to data.The registered class objects and their corresponding C type descriptors are placed in a hashtable.The new-Block later uses this hashtable to convert a class object into the C type descriptor.The type descriptor is required by the C library to allocate an InterWeave block so that it has the information to translate back and forth between local and wire format(see Section3).4.2KaffeJ-InterWeave requires modifications to the byte code in-terpreter and the JIT compiler to implementfine-grained write detection via instrumentation.It also requires changes to the garbage collector to ensure that InterWeave blocks are not accidentally collected.Figure4:Extended Kaffe object header forfine-grained write detection4.2.1Write DetectionTo support diff-based transmission of InterWeave segment updates,we must identify changes made to InterWeave objects over a given span of time.The current C ver-sion of InterWeave,like most S-DSM systems,uses vir-tual memory traps to identify modified pages,for which it creates pristine copies(twins)that can be compared with the working copy later in order to create a diff.J-InterWeave could use this same technique,but only on machines that implement virtual memory.To enable our code to run on handheld and embedded devices,we pursue an alternative approach,in which we instrument the interpretation of store bytecodes in the JVM and JIT. In our implementation,only writes to InterWeave block objects need be monitored.In each Kaffe header,there is a pointer to the object method dispatch table.On most architectures,pointers are aligned on a word boundary so that the least significant bit is always zero.Thus,we use this bit as theflag for InterWeave objects.We also place two32-bit words just before the Kaffe object header,as shown in Figure4.The second word—modification status—records which parts of the object have been modified.A block’s body is logically divided into32parts,each of which corresponds to one bit in the modification status word.Thefirst extended word is pre-computed when initializing an object.It is the shift value used by the instrumented store bytecode code to quickly determine which bit in the modification status word to set(in other words,the granularity of the write detection).These two words are only needed for In-terWeave blocks,and cause no extra overhead for normal Kaffe objects.4.2.2Garbage CollectionLike distributedfile systems and databases(and unlike systems such as PerDiS[13])InterWeave requires man-ual deletion of data;there is no garbage collection.More-over the semantics of InterWeave segments ensure that an object reference(pointer)in an InterWeave object(block) can never point to a non-InterWeave object.As a result, InterWeave objects should never prevent the collection of unreachable Java objects.To prevent Kaffe from acci-dentally collecting InterWeave memory,we modify the garbage collector to traverse only the Kaffe heap.4.3InterWeave C libraryThe InterWeave C library needs little in the way of changes to be used by J-InterWeave.When an existing segment is mapped into local memory and its blocks are translated from wire format to local format,the library must call functions in the IWSegment native library to initialize the Kaffe object header for each block.When generating a description of modified data in the write lock release operation,the library must inspect the modifi-cation bits in Kaffe headers,rather than creating diffs from the pristine and working copies of the segment’s pages.4.4DiscussionAs Java is supposed to be“Write Once,Run Anywhere”, our design choice of implementing InterWeave support at the virtual machine level can pose the concern of the portability of Java InterWeave applications.Our current implementation requires direct JVM support for the fol-lowing requirements:1.Mapping from InterWeave type descriptors to Javaobject classes.2.Managing local segments and the translation be-tween InterWeave wire format and local Java objects.3.Supporting efficient write detection for objects in In-terWeave segments.We can use class reflection mechanisms along with pure Java libraries for InterWeave memory management and wire-format translation to meet thefirst two require-ments and implement J-InterWeave totally in pure Java. Write detection could be solved using bytecode rewrit-ing techniques as reported in BIT[22],but the resulting system would most likely incur significantly higher over-heads than our current implementation.We didn’t do this mainly because we wanted to leverage the existing C ver-sion of the code and pursue better performance.In J-InterWeave,accesses to mapped InterWeave blocks(objects)by different Java threads on a single VM need to be correctly synchronized via Java object monitors and appropriate InterWeave locks.Since J-InterWeave is not an S-DSM system for Java virtual machines,the Java memory model(JMM)[26]poses no particular problems. 5Performance EvaluationIn this section,we present performance results for the J-InterWeave implementation.All experiments employ a J-InterWeave client running on a1.7GHz Pentium-4Linux machine with768MB of RAM.In experiments involving20406080100120_201_co mp r e s s _202_j e s s _205_ra y t r a c e _209_db _213_j a va c _222_m p e g a u d i o _227_m t r t _228_j a c kJVM98 BenchmarksT i m e (s e c .)Figure 5:Overhead of write-detect instrumentation in Kaffe’s interpreter mode01234567_201_c o mp r e s s _202_j e s s _205_r a y t r a c e _209_d b _213_j a v a c _222_m p e g a u d i o _227_m t r t _228_j a c k JVM98 Benchmarks T i m e (s e c .)Figure 6:Overhead of write-detect instrumentation inKaffe’s JIT3modedata sharing,the InterWeave segment server is running on a 400MHz Sun Ultra-5workstation.5.1Cost of write detectionWe have used SPEC JVM98[33]to quantify the perfor-mance overhead of write detection via bytecode instru-mentation.Specifically,we compare the performance of benchmarks from JVM98(medium configuration)run-ning on top of the unmodified Kaffe system to the per-formance obtained when all objects are treated as if they resided in an InterWeave segment.The results appear in Figures 5and 6.Overall,the performance loss is small.In Kaffe’s inter-preter mode there is less than 2%performance degrada-tion;in JIT3mode,the performance loss is about 9.1%.The difference can be explained by the fact that in inter-preter mode,the per-bytecode execution time is already quite high,so extra checking time has much less impact than it does in JIT3mode.The Kaffe JIT3compiler does not incorporate more re-cent and sophisticated technologies to optimize the gener-ated code,such as those employed in IBM Jalepeno [35]and Jackal [38]to eliminate redundant object referenceand array boundary checks.By applying similar tech-niques in J-InterWeave to eliminate redundant instrumen-tation,we believe that the overhead could be further re-duced.5.2Translation costAs described in Sections 3,a J-InterWeave application must acquire a lock on a segment before reading or writ-ing it.The acquire operation will,if necessary,ob-tain a new version of the segment from the InterWeaveserver,and translate it from wire format into local Kaffeobject format.Similarly,after modifying an InterWeavesegment,a J-InterWeave application must invoke a write lock release operation,which translates modified por-tions of objects into wire format and sends the changes back to the server.From a high level point of view this translation re-sembles object serialization ,widely used to create per-sistent copies of objects,and to exchange objects between Java applications on heterogeneous machines.In this sub-section,we compare the performance of J-InterWeave’stranslation mechanism to that of object serialization in Sun’s JDK v.1.3.1.We compare against the Sun im-plementation because it is significantly faster than Kaffe v.1.0.6,and because Kaffe was unable to successfully se-rialize large arrays in our experiments.We first compare the cost of translating a large array of primitive double variables in both systems.Under Sun JDK we create a Java program to serialize double arrays into byte arrays and to de-serialize the byte arrays backagain.We measure the time for the serialization and de-serialization.Under J-InterWeave we create a programthat allocates double arrays of the same size,releases (un-maps)the segment,and exits.We measure the releasetime and subtract the time spent on communication with the server.We then run a program that acquires (maps)the segment,and measure the time to translate the byte arrays back into doubles in Kaffe.Results are shown in Figure 7,for arrays ranging in size from 25000to 250000elements.Overall,J-InterWeave is about twenty-three times faster than JDK 1.3.1in serialization,and 8times faster in dese-rialization.5.3Bandwidth reduction To evaluate the impact of InterWeave’s diff-based wire format,which transmits an encoding of only those bytes that have changed since the previous communication,we modify the previous experiment to modify between 10and 100%of a 200,000element double array.Results appear in Figures 8and 9.The former indicates translation time,the latter bytes transmitted.20406080100120140250005000075000100000125000150000175000200000225000250000Size of double array (in elements)T i m e (m s e c .)Figure 7:Comparison of double array translation betweenSun JDK 1.3.1and J-InterWeave102030405060708090100100908070605040302010Percentage of changesT i m e (m s e c .)Figure 8:Time needed to translate a partly modified dou-ble arrayIt is clear from the graph that as we reduce the per-centage of the array that is modified,both the translationtime and the required communication bandwidth go down by linear amounts.By comparison,object serialization is oblivious to the fraction of the data that has changed.5.4J-InterWeave Applications In this section,we describe the Astroflow application,developed by colleagues in the department of Physics andAstronomy,and modified by our group to take advan-tage of InterWeave’s ability to share data across hetero-geneous platforms.Other applications completed or cur-rently in development include interactive and incremental data mining,a distributed calendar system,and a multi-player game.Due to space limitations,we do not present these here.The Astroflow [11][14]application is a visualization tool for a hydrodynamics simulation actively used in the astrophysics domain.It is written in Java,but employs data from a series of binary files that are generated sepa-rately by a computational fluid dynamics simulation sys-00.20.40.60.811.21.41.61.8100908070605040302010Percentage of changesT r a n s mi s s i o n s i z e (M B )Figure 9:Bandwidth needed to transmit a partly modified double array2040608010012014012416Number of CPUsT i m e (s e c .)Figure 10:Simulator performance using InterWeave in-stead of file I/Otem.The simulator,in our case,is written in C,and runs on a cluster of 4AlphaServer 41005/600nodes under the Cashmere [34]S-DSM system.(Cashmere is a two-level system,exploiting hardware shared memory within SMP nodes and software shared memory among nodes.InterWeave provides a third level of sharing,based on dis-tributed versioned segments.We elaborate on this three-level structure in previous papers [8].)J-InterWeave makes it easy to connect the Astroflow vi-sualization front end directly to the simulator,to create an interactive system for visualization and steering.The ar-chitecture of the system is illustrated in Figure 1(page 1).Astroflow and the simulator share a segment with one header block specifying general configuration parameters and six arrays of doubles.The changes required to the two existing programs are small and limited.We wrote an XDR specification to describe the data structures we are sharing and replaced the original file operations with shared segment operations.No special care is re-quired to support multiple visualization clients or to con-trol the frequency of updates.While the simulation data。
自适应共振理论ART模型自适应共振理论ART(Adaptive Resonance Theory)模型是美国Boston大学的S．Grossberg和A．Carpenet 在1976年提出的。
ART是一种自组织神经网络结构，是无教师的学习网络。
当在神经网络和环境有交互作用时，对环境信息的编码会自发地在神经网中产生，则认为神经网络在进行自组织活动。
ART就是这样一种能自组织地产生对环境认识编码的神经网络理论模型。
ART模型是基于下列问题的求解而提出的：1．对于一个学习系统，要求它有适应性及稳定性，适应性可以响应重要事件，稳定性可以存储重要事件。
这种系统的设计问题。
2．学习时，原有的信息和新信息如何处理，保留有用知识，接纳新知识的关系如何及解决的问题。
3．对外界信息与原存储的信息结合并决策的问题。
......Grossberg一直对人类的心理和认识活动感兴趣，他长期埋头于这方面的研究并希望用数学来刻划人类这项活动，建立人类的心理和认知活动的一种统一的数学模型和理论。
ART就是由这种理论的核心内容并经过提高发展然后得出的。
目前，ART理论已提出了三种模型结构，即ARTt，ART2，ART3。
ART1用于处理二进制输入的信息；ART2用于处理二进制和模拟信息这两种输人；ART3用于进行分级搜索。
ART理论可以用于语音、视觉、嗅觉和字符识别等领域。
1．4．1ART模型的结构ART模型来源于Helmboltz无意识推理学说的协作——竞争网络交互模型。
这个模型如图1—19所示。
从图中看出这个模型由两个协作——竞争模型组成。
无意识推理学说认为：原始的感觉信息通过经历过的学习过程不断修改，直到成为一个真实的感知结果为止。
在图1—19中协作——竞争网络交互模型可以看出；环境输入信号和自上而下学习期望同时对协作——竞争网络1执行输入；而自下而上学习是协作——竞争网络1的输出；同时，自下而上学习是协作——竞争网络2的输人．而自上而下学习期望则是其输出。
收稿日期:20010606基金项目:博士学科点专项科研基金(98021332)和黑龙江省科学技术委员会重大基金资助作者简介:卓桂荣(1968-),女(汉),山东,工程师,博士研究生卓桂荣文章编号:100328728(2002)0420600202并联机床工件自动定位卓桂荣,王知行,刘文涛(哈尔滨工业大学机电学院,哈尔滨 150001)摘 要:根据并联机床的几何约束条件,提出并联机床工件自动定位的算法。
该算法简单实用,对一个复杂曲面可以自动找到其在并联机床工作空间中可以加工的位置。
关 键 词:并联机床;自动定位;Stew art 平台中图分类号:T G 54;T P 242.2 文献标识码:AOn Self -Or ien ta tion of W orkp ieces i n a Para llelM ach i ne ToolZHUO Gu i 2rong ,W AN G Zh i 2x ing ,L I U W en 2tao(Schoo l of M echan ical and E lectrical Engineering ,H arb in In stitu te of T echno logy ,H arb in 150001)Abstract :A m ethod is p resen ted fo r self 2o rien tati on of w o rkp ieces in a parallel m ach ine too l acco rding to the geo 2m etrical restricti on of the parallel m ach ine too l .T he m ethod is si m p le and u sefu l ,in w h ich a comp lex concave 2con 2vex su rface can find its m ach in ing locati on at the w o rk ing space in the parallel m ach ine too l au tom atically .Key words :Parallel m ach ine too l ;Self 2o rien tati on ;Stew art p latfo rm 1 工件自动定位原理并联机床工作空间相对较小且计算复杂,在加工像叶轮、叶片等具有复杂曲面的工件时,如何设置工件的加工位置和空间姿态,以保证工件在工作空间内,使机床刀具能够达到加工面上的所有可能加工点,这就是工件在并联机床工作空间中的定位问题。
不对称自由基反应英文Asymmetric Radical Reactions: An Insight into Their Mechanism and Applications.Introduction.Asymmetric radical reactions have emerged as a powerful tool in organic synthesis, enabling the synthesis of chiral compounds with high enantiomeric purity. These reactions differ significantly from their symmetric counterparts, as they involve the generation and utilization of chiral radicals. These chiral radicals can undergo a range of reactions, including substitution, addition, and cyclization, leading to the formation of enantiomerically enriched products.Mechanism of Asymmetric Radical Reactions.The mechanism of asymmetric radical reactions typically involves three key steps: radical generation, chiralitytransfer, and radical termination.Radical Generation.The first step involves the generation of a radical species. This can be achieved through various methods, such as photolysis, thermal decomposition, or redox reactions. The generated radical can be chiral or achiral, depending on the starting materials and the conditions used.Chirality Transfer.The second step involves the transfer of chirality from a chiral auxiliary or catalyst to the radical species. This chirality transfer can occur through covalent or non-covalent interactions between the catalyst/auxiliary and the radical. The nature of these interactions determines the stereoselectivity of the reaction.Radical Termination.The final step involves the termination of the radicalspecies, leading to the formation of the desired product. This termination can occur through various mechanisms, such as coupling with another radical species, hydrogen atom abstraction, or disproportionation.Applications of Asymmetric Radical Reactions.Asymmetric radical reactions have found widespread applications in various fields of organic synthesis, including the synthesis of natural products, pharmaceuticals, and functional materials.Synthesis of Natural Products.Natural products often possess complex chiral structures, making their synthesis challenging. Asymmetric radical reactions have proven to be effective tools for the synthesis of such chiral natural products. For example, the use of chiral radicals generated from appropriate precursors has enabled the enantioselective synthesis of alkaloids, terpenes, and amino acids.Pharmaceutical Applications.The enantiomers of chiral drugs often differ significantly in their biological activities, making it crucial to control their enantiomeric purity. Asymmetric radical reactions can be used to synthesize enantiomerically enriched chiral drugs with high selectivity. This approach has been successfully applied to the synthesis of various drugs, including anti-inflammatory agents, anticancer agents, and antiviral agents.Functional Materials.Chiral materials possess unique physical and chemical properties that make them useful in various applications, such as displays, sensors, and catalysts. Asymmetricradical reactions can be used to synthesize chiral building blocks for the preparation of such materials. For instance, chiral polymers can be synthesized by utilizing asymmetric radical polymerization reactions, leading to the formation of materials with controlled chirality and tailored properties.Conclusion.Asymmetric radical reactions have emerged as powerful tools for the synthesis of enantiomerically enriched chiral compounds. Their unique mechanism, involving chirality transfer from a chiral catalyst/auxiliary to the radical species, enables high selectivity and enantiopurity in the product. The widespread applications of asymmetric radical reactions in organic synthesis, particularly in the synthesis of natural products, pharmaceuticals, and functional materials, highlight their importance in modern chemistry.Future Perspectives.Despite the significant progress made in the field of asymmetric radical reactions, there are still numerous challenges and opportunities for further exploration.Improving Selectivity and Efficiency.One of the key challenges in asymmetric radical reactions is achieving high selectivity and efficiency. While significant progress has been made in this area, there is still room for improvement. Future research could focus on developing new chiral catalysts/auxiliaries that can promote asymmetric radical reactions with higher selectivity and efficiency.Expanding the Scope of Reactions.Currently, the scope of asymmetric radical reactions is limited by the availability of suitable precursors and the reactivity of the generated radicals. Future research could aim to expand the scope of these reactions by developing new methods for generating radicals with desired functionalities and reactivities.Applications in Sustainable Chemistry.In the context of sustainable chemistry, asymmetric radical reactions offer an attractive alternative to traditional synthetic methods. By utilizing renewableresources and mild reaction conditions, asymmetric radical reactions could contribute to the development of more sustainable synthetic routes for the preparation of chiral compounds.Integration with Other Techniques.The integration of asymmetric radical reactions with other techniques, such as photocatalysis, electrochemistry, and microfluidics, could lead to the development of new and innovative synthetic methods. By combining the advantages of these techniques, it may be possible to achieve even higher selectivity, efficiency, and scalability in asymmetric radical reactions.In conclusion, asymmetric radical reactions have emerged as powerful tools for the synthesis of enantiomerically enriched chiral compounds. While significant progress has been made in this area, there are still numerous opportunities for further exploration and development. Future research in this field could lead tothe discovery of new and innovative synthetic methods with improved selectivity, efficiency, and sustainability.。
