Marios Kleanthous

Yiannakis Sazeides

Marios D Dikaiakos

Extrinsic and Intrinsic Text Cloning

Text Cloning occurs when a processor is storing in one or more levels of its cache hierarchy the same text multiple times. There are several causes of Text Cloning and we classify them either as Extrinsic or Intrinsic.

Extrinsic Text Cloning can happen due to user and software practices, or middleware policies, which result into making multiple copies of a binary and concurrently executing the multiple copies on the same processor.

Intrinsic Text Cloning can happen when an instruction cache is Virtually Indexed/Virtually Tagged and the process identifier is included in the tag. A simultaneous multithreaded processor, that employs such cache, will map the text of concurrent processes of the same binary to different instruction cache space due to their distinct process identifier.

Text cloning can be wasteful to performance, especially for simultaneous multithreaded processors, because concurrent processes compete for cache space to store the same instruction blocks. Experimental results on simultaneous multithreaded processors indicate that the performance overhead of this type of undesirable cloning is significant. Theses findings call for OS and/or architectural support to reduce or eliminate Text Cloning.

Introduction

Power constraints and diminishing returns from increasing the issue width on superscalar processors have lead to the emergence of general-purpose single-chip multi-core processors. Furthermore, with continuous technology miniaturization more and more cores are integrated on-chip. Cores are typically multithreaded [START_REF] Yamamoto | Performance estimation of multistreamed, superscalar processors[END_REF][START_REF] Tullsen | Simultaneous Multithreading: Maximizing On-Chip Parallelism[END_REF] to leverage unutilized core resources, due to a stalled or low performing thread, to execute concurrently multiple threads in the same processor. Niagara2 [START_REF] Shah | Ultrasparc t2: A highly-threaded, power-efficient, sparc soc[END_REF] contains 8 cores each supporting 8 threads, Intel's i7 [START_REF] Casazza | First the tick, now the tock: Intel microarchitecture (nehalem)[END_REF] contains a quad core each 2-way simultaneous multithreaded (SMT), and Power7 [START_REF] Sinharoy | Power7 multi-core processor design[END_REF] contains 8 cores each 4-way SMT.

The combination of multi-cores and multi-threading is effective in improving processor utilization as long as the memory hierarchy can satisfy all running threads instructions and data needs. Consequently, modern processors devote a large fraction of their real estate for the cache hierarchy and numerous research studies are conducted on how to efficiently share the cache hierarchy among concurrent on-chip threads [START_REF] Beckmann | Managing wire delay in large chip-multiprocessor caches[END_REF][START_REF] Chishti | Optimizing replication, communication, and capacity allocation in cmps[END_REF][START_REF] Shayesteh | Dynamically configurable shared cmp helper engines for improved performance[END_REF].

In this work we identify Text Cloning as a potential inefficiency in the cache hierarchy of modern multi-core processors. Text Cloning occurs when a processor is storing at one or more levels of its cache hierarchy the same text multiple times. Text cloning can be wasteful to performance, especially for SMT cores, because processes compete for cache space to store the same instruction blocks at the same time. There are several causes of text cloning and we divide them into Extrinsic and Intrinsic.

Extrinsic Text Cloning can happen when a user, many users, or middleware, copy a binary and concurrently execute the multiple copies on the same processor. The Operating System is unable to detect that these binaries are identical and will map them during execution in different physical address space, therefore, creating unnecessary pressure at all cache levels. Such a scenario is very common in Grid Computing job flow where the binary of each submitted job is copied in a temporary directory, a sandbox, with all its inputs and data.

Intrinsic Text Cloning can happen when an instruction cache is Virtually Indexed/Virtually Tagged and the process identifier (PID) is included in the tag. A simultaneous multithreaded processor , that uses such cache, will map the text of concurrent processes of the same binary to different instruction cache space due to their distinct process identifier. A Virtually Indexed/Virtually Tagged instruction cache is found in the Intel's hyperthreaded (SMT) Netburst microarchitecture [START_REF] Koufaty | Hyper-Threading Technology in the Netburst Microarchitecture[END_REF].

This paper identifies and explains the causes of Text Cloning both, Extrinsic and Intrinsic, and demonstrates experimentally, on real and simulated SMT hardware, the significant performance implications of Text Cloning. The paper discusses ways to mitigate the effects of Text Cloning and shows the potential of a hardware-based approach to identify and eliminate it.

The rest of the paper is organized as follows: Section 2 discusses the various causes of Extrinsic and Intrinsic Text Cloning, demonstrates the sensitivity of real hardware performance to text cloning and discusses possible ways to mitigate its detrimental effects. Sections 3 describes in detail the problem of Text Cloning in Grid Computing Systems. Section 4 presents simulation based experimental analysis that underlines the importance of eliminating text cloning and demonstrates that a hardware based scheme can effectively identify text cloning and eliminate it. Section 5 presents related work on cache duplication and, finally, in Section 6 we conclude.

2 Text Cloning: Causes, Implications, Remedies This section introduces Extrinsic and Intrinsic Text Cloning through discussion about when it can occur, how much it hurts performance and possible methods to avoid it.

Extrinsic Text Cloning

Extrinsic Text Cloning (ETC) can happen due to user and software practices that result in the execution of multiple copies of the same binary on the same processor. The Operating System is unable to understand that these binaries are clones and will map them in different physical address spaces. Consequently, each process is associated to a different text segment and will eventually create duplication in shared caches of the processor.

The ETC is common within Grid Computing Systems [START_REF] Foster | The anatomy of the grid -enabling scalable virtual organizations[END_REF] due to Grid's distributed file system and the middle-ware design. In particular, typical Grid job flow requires the binary of each submitted job to be copied in a temporary directory, a sandbox, with all its inputs and data. Although Grid computing consists of a large number of computing nodes and provides high throughput, its efficiency is highly dependent on the middle-ware that schedules and submits the different jobs to computing nodes. In the case that two or more jobs, that use the same binary, are submitted to the same multicore or SMT computing node the middle-ware, or even the OS in the Grid computing node itself, is unaware of this duplication.

Another emerging case of ETC is due to virtualized cloud computing where multiple users can run local copies of the same applications that happen to execute on the same physical processor [START_REF] Services | Amazon elastic compute cloud: User guide[END_REF].

Furthermore, ETC can happen when an application contains self-modifying code routines. When a process, that shares its physical address space with other processes, self modifies its code then the memory page that contains the modified code has to be copied in different address. This will result to duplicated blocks that were contained in the copied memory page but remain unaffected from the code self-modifying routine [START_REF] Arm | Cortex-A8 Technical Reference Manual[END_REF].

Finally, a common habit among users is to keep their own copies of same applications in their home directories. This might lead in ETC when two users are logged in the same machine and run the same application, using their own copy.

Intrinsic Text Cloning

Intrinsic Text Cloning (ITC) is specific to VIVT instruction caches. A VIVT cache uses the Virtual Address to tag match a block. In the case of a shared VIVT cache the tag also contains the PID of the process to avoid homonym problems. However, each instance of the application will have different PID and this will create synonyms [START_REF] Smith | Cache Memories[END_REF] in the instruction cache. ITC is equivalent to the occurrence of synonyms in an instruction cache.

VIVT caches are used for L1 Instruction caches to have lower access latency and lower energy per access by avoiding ITLB translations on every cache access. Cloning in IL1 caches only occurs when the tag of the Virtually Tagged (VT) caches includes also the PID. Single thread cores do not require keeping the process ID in the tag unless they want to avoid cache flashing after each context switch. On the other hand, for an SMT processor, the PID is essential in the tag of a VT cache because multiple threads co-exist in the cache at the same time.

The ITC can happen either when we run multiple copies of the same binary or multiple instances of the same binary. For the first scenario, the reasons are the same as those discussed in Section 2.1. The second scenario, multiple instances of the same binary, is very common when running the same application with different inputs, or using applications that by default create a different process for each instance due to lack of multithreading support or other programming reasons. For example, versions of Microsoft Excel and Internet Explorer create a distinct instance each time they are invoked.

Another possible cause of ITC is the service daemons running on servers. Not all of these applications are multithread, and create a different process each time a user request the service. A very common category of services that spawns multiple processes are the kernel services.

How important is ETC and ITC

This Section uses two real processors with 2-way SMT cores, the Intel Pentium 4 (P4) [START_REF] Sager | The microarchitecture of the pentium 4 processor[END_REF] with VIVT 12KB Trace Cache and the Intel i7 [START_REF] Casazza | First the tick, now the tock: Intel microarchitecture (nehalem)[END_REF] with a VIPT 32KB IL1 cache to measure the performance impact of Text Cloning in IL1 cache. We used a synthetic benchmark (see APPENDIX) that exercises the instruction cache by executing a large basic block of calculations for different basic block sizes. The benchmark has minimal data requirements, only few initial capacity misses, effectively no-conditional branches and several random indirect unconditional branches to measure only the impact of the instruction references on performance.

We measure the implications of ETC and ITC by performing two experiments for each processor. First, two instances of the same binary are executed in parallel. The OS is aware that both processes refer to the same binary and it will load the text only once in the physical address space but it will create two different virtual address spaces, one for each process. This causes ITC only in the P4 with VIVT caches since the address mapping of the threads in the i7 VIPT cache will be the same. For the second experiment, two copies of the same binary are run again in parallel for the SMT execution. This causes the two processes to be mapped in different physical address spaces and as a result different virtual address spaces. This manifests into Text Cloning both for P4 and i7 caches in all levels of the cache hierarchy.

For both experiments, the two processes are forced to run on the same logical core using the taskset command. In this way the two processes will be executed in parallel using one SMT core and share the same IL1 cache.

Intel Pentium 4 with a VIVT IL1

Figure 1 shows the results for the Intel P4. The y-axis of the figure shows the SMT speedup compared to running the two processes back to back. The x-axis shows the static instruction footprint of each process. For the VIVT IL1 cache of P4, running either copies or multiple instances of the same binary does not make any difference. In both cases the two processes will be mapped in different virtual address spaces. The evidence for ETC (two copies) and ITC (same binary) are supported by the behavior from 1KB to 12KB instruction footprint. For this sizes the single thread will fit perfectly on the IL1 cache while the SMT executions will suffer with cache misses after the 6KB instruction footprint. In the figure, we can clearly see that the speedup of SMT for both experiments is dropping once the instruction footprint exceeds the 6KB from 80% down to 55% for 12KB.

Intel i7 with a VIPT IL1

Figure 2 shows the effects of running concurrently the same binary and two copies of the binary on an i7. The trends for i7 are clearly different as compared to P4. In particular, comparing the two bars in Figure 2 we observe that when running two different copies of the same binary the SMT speedup is reduced when we go beyond the 16KB instruction footprint because now the combined workload of the two copies occupies 32KB in total which barely fits the i7 32KB IL1 cache. This is clearly due to ETC. On the other hand, the runs with the same binary experience no Text Cloning, as opposed to P4. Specifically, with the 16KB instruction footprint the instructions of both processes are mapped in the same physical space and hence are mapped only once in the VIPT IL1 cache of i7.

Comparing Figures 1 and2 we clearly see that ETC can affect both cores while ITC affects only Pentium 4 that uses a VIVT IL1 cache.

How to eliminate ETC and ITC

ETC can be avoided if the OS is enhanced with the ability to detect copies of the same binary and map them at the same physical address space. This however can cause security problems since someone can exploit this to inject harmful code in applications that are commonly used among many users.

Another possible solution is to enable the hardware to detect this duplication with hints from the OS or in real time to completely avoid user intervention. At this low level, the detection of cloned text can be more efficient and more secure. Two such mechanisms that have already been proposed are [START_REF] Kleanthous | Catch: A mechanism for dynamically detecting cache-content-duplication and its application to instruction caches[END_REF][START_REF] Mohamood | DLL-conscious Instruction Fetch Optimization for SMT Processors[END_REF] and with certain modifications can be applied to ETC.

More specifically [START_REF] Kleanthous | Catch: A mechanism for dynamically detecting cache-content-duplication and its application to instruction caches[END_REF] proposed CATCH, a mechanism that dynamically detects and eliminates duplicated instruction sequences, valid blocks, from the IL1 cache. Duplicate instructions sequences can exists because of copy paste programming, macro expansion, function inlining and other compiler and programming optimizations. Mohamood et al. [START_REF] Mohamood | DLL-conscious Instruction Fetch Optimization for SMT Processors[END_REF] proposed a mechanism to detect DLL sharing between different threads that use the same DLLs. The mechanisms described are based on both VIVT and VIPT caches that are aware of DLL sharing using a bit in the ITLB table that is set with aid of the Operating System. The mechanisms described can be used to prevent text cloning but we believe that a simpler mechanism may be sufficient because the granularity of duplication is much bigger in the Text Cloning scenario.

ITC can be avoided by using a VIPT IL1 cache. The VIPT cache requires an access to the ITLB on very cache access to translate the Virtual to Physical address. This costs both energy for accessing the ITLB but also performance because even though the Indexing in a VIPT can be done with Virtual address this is not enough to hide the ITLB access and tag matching. This extra translation might increase more than a cycle the IL1 cache access latency. Previous SMT processors, like Intel Pentium 4, kept the L1 Instruction Cache to be VIVT but modern processors, like Intel i7, have a Virtually Indexed/Physically Tagged (VIPT) cache with the extra overhead of the ITLB translation on every IL1 cache access. Therefore, the particular instruction cache configuration may depend on power and performance trade-offs.

Another possible solution for the ITC problem is the hardware mechanisms proposed to detect and eliminate Cache-Content-Duplication dynamically [START_REF] Kleanthous | Catch: A mechanism for dynamically detecting cache-content-duplication and its application to instruction caches[END_REF][START_REF] Mohamood | DLL-conscious Instruction Fetch Optimization for SMT Processors[END_REF]. These mechanism may help eliminate both ETC and ITC.

Grid Computing Systems

In this section we will explain in detail how and where Extrinsic Text Cloning manifests in Grid Computing Systems and specifically in EGEE project [START_REF]Enabling Grids for E-sciencE[END_REF].

Grid Architecture

Figure 3 shows the basic components of EGEE grid system that uses the gLite middleware to submit, schedule, execute and manage users' jobs. The figure shows that this grid computing systems is composed from four basic elements, (a) the User Interface (UI), (b) the Workload Management System (WMS), (c) the Computing Element (CE) and (d) the Worker Node (WN) [START_REF] Marco | The glite workload management system[END_REF].

The UI provides the tools for the user to submit or cancel his job and also to retrieve the output result of the submitted job. Once a job is submitted from a UI it arrives to a WMS. The WMS is responsible for the load balancing of the whole grid infrastructure by keeping records of the balance in each cluster and which clusters are available for execution. Once the WMS chooses the cluster to submit a job it sends the job description in a WMS wrapper script to the appropriate CE of the cluster. The CE is responsible for keeping track of the workload in its own cluster and submits jobs to different WNs that belong to the cluster. Finally the WN is running a job resource manager, for EGEE is Torque/PBS, which executes the WMS job wrapper script that setup, download and upload the job's sandbox, execute the job, log and clean up once the job is done.

Extrinsic Text Cloning in Grid

ETC is caused by the very last stage of the grid job flow, at the WN, where the WMS job wrapper creates a different sandbox for each job. This prevents multiple jobs that run on the same worker node, multicore or SMT, to share their binaries but also provides secure execution of the job.

The architecture of grid is build to provide abstraction in each level but also security for the users to run their job without interfering with each other [START_REF] Foster | The anatomy of the grid -enabling scalable virtual organizations[END_REF].

This approach provides little or no opportunity to the middleware to optimize job submission and execution to share binaries because there is a high risk of compromising security. For example, even if the WMS component is smart enough to group jobs together that use the same binary and submit them to the same CE it would still need to run in different sandboxes to prevent interference between jobs' inputs and outputs and even malicious activity from other users that may try to exploit this hole.

Accordingly to eliminate ETC in grid computing either the OS running on the worker node or hardware support or a codesign of the two is essential.

For example, a service running in the OS that compares the binaries start executing with binaries already running can be used. This can be done using a table that keeps a content id (e.g. the CRC code) of the text of all running binaries. When a new binary starts executing, its content id is compared with all the running ones and if there is a match the texts are compared for validation. If two texts are identical they can be mapped at the same physical address space. In case of self-modifying code the OS must be aware to split merged texts into different physical address spaces. This technique will require no hardware modifications but requires for the OS to do all the comparisons and monitoring for self-modifying code or another possibly malicious actions from the users.

Another approach is to have a hardware mechanism detecting text cloning. The granularity of duplication can be chosen statically for each set of binaries or it can change dynamically. For example, for two identical binaries only a relation between the PIDs needs to be recorded. On the other hand if two binaries are very similar but not identical, for example an open source simulator that is slightly modified by each user, detection at the granularity of pages or cache blocks is more appropriate. By reducing the detection granularity, the duplication opportunity increases but the number of relations to be recorded increases also. An adaptive mechanism might be useful to keep the cost low when possible by changing the granularity. Smaller granularity also provides duplication detection across very different applications and even within the same binary. Furthermore, detecting self-modifying code and invalidating relations is easier in hardware because it can monitor the instructions that write the text segment.

A more efficient design will be the combination of software and hardware. For example, a co-design where an OS software mechanism provides hints, for the relations and the text cloning granularity, to the hardware mechanism that will validate, create and detect the duplicate relations. The OS has a broader view of the processes running and can detect if two texts are identical, similar or very different. This can help the hardware mechanism to adapt the granularity to detect text duplication. Finally, the hardware can detect self-modifying code and invalidate any relations that become invalid.

Provided that Text Cloning is a frequent phenomenon, future work should evaluate and engineer all these options to determine how to best to detect and eliminate it.

Evaluation using simulation

For simulation evaluation of the effects of text cloning we consider only the scenario where multiple copies of the same binary are executed using a VIPT IL1 cache of an SMT core. This corresponds to a scenario with Extrinsic Text Cloning (ETC).

Experimental framework

In order to evaluate the performance we have used the SMT-SIM simulator [START_REF] Tullsen | Simulation and modeling of a simultaneous multithreading processor[END_REF] with a selection of 7 benchmarks of the SPEC2000 suite. The 7 benchmarks selected where 3 with a large instruction workload, fmad3d, crafty and perl, 2 with a medium instruction workload eon and vortex, and 2 with a small instruction workload load, ammp and lucas. This benchmark selection is done to show the potential performance of ETC for different cases of instruction cache pressure. All benchmarks are run using reference inputs.

Table 1 shows the processor configuration used and Table 2 shows the skipped, executed and shift regions of the benchmarks used. The shift region is the difference in dynamic instructions between the two copies of the binary that are executed simultaneously to avoid overlapping program phases. For these shift regions we have verified that there is no overlapping between the simulated regions of the two copies. The skipped and executed regions were selected using a Simpoint-like tool [START_REF] Sherwood | Automatically characterizing large scale program behavior[END_REF].

Results

Figure 4 shows the Weighted Speedup [START_REF] Snavely | Symbiotic job scheduling for a simultaneous multithreaded processor[END_REF] normalized to the first bar, which is the performance of 2 instances of the same binary running on an SMT processor. For experiments in Figure 4 all applications are running synchronized, that means they are executing exactly the same program phase. The results show that the performance degradation due to ETC, when running 2 copies of the same binary, is up to 60% for crafty and more than 20% for the other benchmarks. For lucas and ammp that have very little pressure on the instruction cache ETC does not affect the performance.

Figure 5 shows a more common scenario where the two applications running simultaneously are in different program phase, 500 million instructions shift, in their execution. We have verified that none of the applications is overlapping with its copy during the execution. The results here show that the performance degradation is a little less, mainly because by executing a different phase we can avoid some conflict misses. Still the bigger instruction footprint due to ETC can cause 55% slowdown for eon and crafty and about 20% for the other benchmarks. The ammp and lucas are again not affected by ETC due to the very small instruction cache workload.

These results suggest that the use of a hardware mechanism, OS support or a combination of the two will be useful to eliminate the performance degradation due to text cloning. In this work we chose a mechanism, proposed in [START_REF] Kleanthous | Catch: A mechanism for dynamically detecting cache-content-duplication and its application to instruction caches[END_REF], to show how a hardware mechanism can be used to recover performance loss due to Text Cloning.

Figure 4 shows how CATCH can reduce the overhead of cloning. The third bar shows the performance when two copies of the same binary are executing and CATCH is used to detect and eliminate cloning. We can see that when using CATCH the performance degradation is reduced to 0.07% on average. There is even one case, for vortex, that the performance of CATCH is even better compared to the run where we have executed the same binary twice. This is because CATCH detects duplication not only across different binaries, but also within the same binary and thus improving the performance of the single thread execution.

The results in Figure 5 are similar to 4 but this time we can see that CATCH eliminates completely the cloning overheads on average. We would like to note again that CATCH is not for free and each duplication detection is penalized with one extra cycle that corresponds to an extra cache access to use the duplicated block. The CATCH mechanism is described in detail in [START_REF] Kleanthous | Catch: A mechanism for dynamically detecting cache-content-duplication and its application to instruction caches[END_REF].

We have used CATCH as a case study to show how a hardware mechanism can be applied to eliminate ETC. The results indicate that an Operating System mechanism or a hardware mechanism that is aware of text cloning can be very useful to improve the performance of modern platforms that suffer from ETC, such as the Grid Computing and Cloud Computing Systems .

Related work

Previous work on mitigating code duplication mainly aim to compress the instructions by either profiling the applications or by dynamically detecting and correlating duplicated sequences.

Lefurgy et al. [START_REF] Lefurgy | Improving Code Density Using Compression Techniques[END_REF] explored the idea of keeping compressed code in instruction memories of embedded processors. Based on static analysis, common sequences of instructions are assigned unique codes. These codes are stored in instruction memory and are expanded to their original form after being read.

Code compaction work has also been dealing with the reduction of static code of a single binary [START_REF] Beszedes | Survey of Code-Size Reduction Methods[END_REF][START_REF] Cooper | Enhanced Code Compression for Embedded RISC Processors[END_REF][START_REF] Debray | Compiler Techniques for Code Compaction[END_REF]. Code compaction methods are used to reduce the executable code size without a need to decompress the compacted code to execute it.

Harizopoulos and Ailamaki [START_REF] Harizopoulos | Improving instruction cache performance in oltp[END_REF] proposed the synchronization of threads in OLTP applications. By synchronizing different threads of the same application to reuse the instructions between them, the total instruction cache footprint of the appli- Biswas et. al. [START_REF] Biswas | Multi-execution: multicore caching for data-similar executions[END_REF] investigate the phenomenon of data similarity in multi-execution programs. They observed that when multiple instances of the same application are running on a multicore sharing the same L2-cache, their data are usually very similar.

All these techniques tried to dynamically detect and exploit duplication at the granularity of cache blocks. In the case of text cloning the duplication can be detected at the granularity of memory pages or even the whole binary, with the help of the Operating System or simple hardware mechanisms.

Conclusions

This work analyzes the effects of Extrinsic and Intrinsic Text Cloning (ETC) in caches. Extrinsic text cloning can occur when a binary is copied and executed concurrently multiple times, for example in Grid Computing Systems. In that case the OS is unaware of the Text Cloning and two or more copies of the same binary will be mapped in different physical addresses. Intrinsic Text Cloning (ITC) can occur in the case of Virtually Index/Virtually Tagged caches where the same text segment is mapped in different virtual address spaces.

We evaluate the effects of ETC and ITC, using two SMT Intel processors, P4 and i7 with a synthetic benchmark. The results indicate that the slowdown in execution due to Text Cloning is significant and a mechanism for detecting and eliminating this overhead can be important.

Simulation based evaluation has shown that the performance overheads of ETC can be completely eliminated using a hardware mechanism previously proposed to detect duplication between instruction sequences.

Overall, the analysis in this paper suggests the importance of OS and architectural support to eliminate Text Cloning. As a next step we plan to characterize the Text Cloning in Grid Computing and Cloud Computing frameworks to determine its frequency and performance implications in a realistic setup.

Figure 2 :

 2 Figure 2: Intrinsic and Extrinsic Text Cloning in Intel i7

Figure 3 :

 3 Figure 3: gLite job submission chain (http://web.infn.it/gLiteWMS/index.php/techdoc/howtosandguides)

Figure 4 :Figure 5 :

 45 Figure 4: Weighted SpeedUp. Detecting and eliminating ETC with overlapping program phases

A

  APPENDIX: Synthetic Benchmark to exercises Instruction Caches v o i d emptyFunc ( ) { r e t u r n ; } u n s i g n e d l o n g l o n g x = 0 ; v o i d oddN ( ) { x = 0 ; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; r e t u r n ; } v o i d evenN ( ) { x = 0 ; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; r e t u r n ; } v o i d ( * f u n c t i o n N [ 3 ] ) ( ) = {&emptyFunc ,&oddN ,& evenN } ; i n t execFlagN -1 = 1 ; v o i d oddN -1(){ x = 0 ; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; execFlagN -1 = execFlagN -1 && ! ( d e p t h == 2 ) ; i n t c a l l F u n c = g e n r a n d ( ) & ( execFlagN -1);f u n c t i o n N [ execFlagN -1 + c a l l F u n c ] ( ) ; f u n c t i o n N [ execFlagN -1 + ( ( c a l l F u n c ˆ1 ) & execFlagN -1 ) ] ( ) ; execFlagN -1 ˆ= 1 ; r e t u r n ; } v o i d evenN -1(){ x = 0 ;x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; execFlagN -1 = execFlagN -1 && ! ( d e p t h == 2 ) ; i n t c a l l F u n c = g e n r a n d ( ) & ( execFlagN -1);f u n c t i o n N [ execFlagN -1 + c a l l F u n c ] ( ) ; f u n c t i o n N [ execFlagN -1 + ( ( c a l l F u n c ˆ1 ) & execFlagN -1 ) ] ( ) ; execFlagN -1 ˆ= 1 ; r e t u r n ; } v o i d ( * f u n c t i o n N -1 [ 3 ] ) ( ) = {&emptyFunc ,&oddN-1,&evenN -1}; . . . v o i d ( * f u n c t i o n 2 [ 3 ] ) ( ) = {&emptyFunc ,& odd2 ,& e ve n 2 } ; i n t e x e c F l a g 1 = 1 ; v o i d odd1 ( ) { x = 0 ; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; e x e c F l a g 1 = e x e c F l a g 1 && ! ( d e p t h == 1 ) ; i n t c a l l F u n c = g e n r a n d ( ) & ( e x e c F l a g 1 ) ; f u n c t i o n 2 [ e x e c F l a g 1 + c a l l F u n c ] ( ) ; f u n c t i o n 2 [ e x e c F l a g 1 + ( ( c a l l F u n c ˆ1 ) & e x e c F l a g 1 ) ] ( ) ; e x e c F l a g 1 ˆ= 1 ; r e t u r n ; } v o i d e v e n 1 ( ) { x = 0 ; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; x ++; e x e c F l a g 1 = e x e c F l a g 1 && ! ( d e p t h == 1 ) ; i n t c a l l F u n c = g e n r a n d ( ) & ( e x e c F l a g 1 ) ; f u n c t i o n 2 [ e x e c F l a g 1 + c a l l F u n c ] ( ) ; f u n c t i o n 2 [ e x e c F l a g 1 + ( ( c a l l F u n c ˆ1 ) & e x e c F l a g 1 ) ] ( ) ; e x e c F l a g 1 ˆ= 1 ; r e t u r n ; } v o i d ( * f u n c t i o n 1 [ 3 ] ) ( ) = {&emptyFunc ,& odd1 ,& e v e n 1 } ; i n t main ( i n t a r g c , c h a r * a r g v [ ] ) { u n s i g n e d l o n g l o n g i = 0 ; u n s i g n e d l o n g l o n g k = a t o i ( a r g v [ 1 ] ) ; d e p t h = a t o i ( a r g v [ 2 ] ) ; s t r u c t t i m e v a l t s t a r t , t f i n ; g e t t i m e o f d a y (& t s t a r t , NULL ) ; f o r ( i = 0 ; i < k ; i ++){ i n t c a l l F u n c = g e n r a n d ( ) & ( 0 x1 ) ; f u n c t i o n 1 [ c a l l F u n c + 1 ] ( ) ; f u n c t i o n 1 [ ( c a l l F u n c ˆ1 ) + 1 ] ( ) ; } g e t t i m e o f d a y (& t f i n , NULL ) ; t i m e v a l s u b t r a c t (& t f i n ,& t s t a r t ) ; r e t u r n 0 ; }

Table 2

 2 also includes the misses per 1K instructions for each benchmark for a 16KB L1 instruction cache that are used as criterion for the selection of the benchmarks.

	fetch/issue/commit width				4/4/4
	INT Issue Queue/FP Issue Queue/ROB		64/64/256
	Pipeline Stages				10
	L1 instruction cache			VIPT 16KB 8-way 32B/block, 1 cycle
	L1 data cache			VIPT 16KB 8-way 32B/block, 1 cycle
	L2 unified cache		VIPT 512KB 8-way 32B/block, 20 cycles
	Main memory latency				200 cycles
	Table 1: Processor Configuration
	SPECINT	Skip	Execute Shift	Misses Per
	2000	(10 6 )	(10 6 )	(10 6 ) 1K instructions
	fma3d	10250	120	500	27.191
	crafty	950	240	500	24.841
	perlbmk	13800	240	500	21.758
	eon	26400	240	500	13.491
	vortex	18550	240	500	6.222
	ammp	4950	240	500	0.006
	lucas	2650	240	500	0.002

Table 2 :

 2 Simulated benchmarks

Acknowledgments

This work was supported by Intel and University of Cyprus grants and in part by the European Commission under the Seventh Framework Programme through the SEARCHiN project (Marie Curie Action, contract number FP6-042467) and the Enabling Grids for E-sciencE project (contract number INFSO-RI-222667).

We would like to acknowledge the efforts of all Cyprus Grid members for providing us the support and resources for this work.


Claudiu Coanda

Florentin Smarandache

Ion Patrascu

A Class of Orthohomological Triangles

de niveau recherche, publiés ou non, émanant des établissements d'enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

1

A Class of Orthohomological Triangles

Prof. Claudiu Coandă, National College "Carol I", Craiova, Romania. Prof. Florentin Smarandache, University of New Mexico, Gallup, USA Prof. Ion Pătraşcu, National College "Fraţii Buzeşti", Craiova, Romania.

Abstract.

In this article we propose to determine the triangles" class i i i A B C orthohomological with a given triangle ABC , inscribed în the triangle ABC ( , ,

i i i A BC B AC C AB   
).

We"ll remind, here, the fact that if the triangle

i i i
A B C inscribed in ABC is orthohomologic with it, then the perpendiculars in , ii AB , respectively in A B C , it will be sufficient to solve the following problem.

Problem.

Let"s consider a point i P in the plane of the triangle ABC and i i i A B C its pedal triangle. Determine the locus of point i P such that the triangles ABC and i i i

A B C to be homological.

Solution.

Let"s consider the triangle ABC , (1, 0, 0), (0,1, 0), (0, 0,1)

A B C
, and the point ( , , ),

0 i P          .
The perpendicular vectors on the sides are:

      2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 , , , 2 , , , 2 BC
CA AB U a a b c a b c U a b c b a b c U a b c a b c c                   
The coordinates of the vector BC  are (0, 1,1)



, and the line BC has the equation 0 x  . The equation of the perpendicular raised from point i P on BC is:

2 2 2 2 2 2 2 0 2 x y z a a b c a b c          
We note ( , , ) i A x y z , because The coordinates y and z of i A can be found by solving the system of equations

2 2 2 2 2 2 2 2 0 2 0 x y z a a b c a b c yz                  
We have:

2 2 2 2 2 2 2 2 2 2 yz a a b c a a b c              ,     2 2 2 2 2 2 2 2 2 2 y a b c a z a b c a                      ,     2 2 2 2 2 2 2 2 2 1 2 a b c a yy a b c a              ,       2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 2 a b c a a b c a y a b c a                    ,     2 2 2 2 2 2 1 2 a y a b c a             , it results   2 2 2 2 2 y a b c a           2 2 2 2 2 2 22 11 22 z y a b c a b c aa                 . Therefore,     2 2 2 2 2 22 0, , 22 i A a b c a b c aa            .
Similarly we find:

    2 2 2 2 2 2 22 , 0, 22 i B a b c a b c bb             ,     2 2 2 2 2 2 22 , , 0 22 i C a b c a b c cc             . We have:             2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 cos 2 cos 2 cos 2 cos 2 cos 2 cos 2 i i i i i i a b c AB c B a a b C a AC a b c a a b c BC a C b b c A b BA abc a abc CA b A c c a B c CB a b c c                                                               .
(We took into consideration the cosine"s theorem:

2 2 2 2 cos a b c bc A   
). In conformity with Ceva"s theorem, we have:

1 i i i iii A B B C C A A C B A C B           .       cos cos cos a c B b a C c b A                 cos cos cos a b C b c A c a B                   2 2 2 2 2 2 2 2 cos cos cos cos cos cos a b c A B C b c a B A C                 2 2 2 2 cos cos cos 0 c a b C A B        .
Dividing it by 2 2 2 abc , we obtain that the equation in barycentric coordinates of the locus L of the point i P is:

    2 2 2 2 2 2 2 2 cos cos cos cos cos cos A B C B A C a c b b a c                           22 22 cos cos cos 0 C A B c b a           . We note , , A B C
ddd the distances oriented from the point i P to the sides , BC C A respectively AB , and we have:

, , 2 2 2 C AB d dd a s b s c s      
.

The locus" L equation can be written as follows:

        2 2 2 2 cos cos cos cos cos cos A C B B A C d d d A B C d d d B A C          22 cos cos cos 0 C B A d d d C A B    
Remarks.

1. It is obvious that the triangle"s ABC orthocenter belongs to locus L. The orthic triangle and the triangle ABC are orthohomologic; a orthological center is the orthocenter H , which is the center of homology. 2. The center of the inscribed circle in the triangle ABC belongs to the locus L, because

= = A B C d d d r 
and thus locus" equation is quickly verified.

Theorem (Smarandache-Pătraşcu).

If a point P belongs to locus L, then also its isogonal ' P belongs to locus L.

Proof.

Let  

,, P    a point that verifies the locus" L. equation, and   ' ' ' '

,,

P    its isogonal in the triangle ABC . It is known that ' ' ' 2 2 2 a b c       .
We"ll prove that ' P  L, i.e.

 

' '2 '2 22 cos cos cos 0 A B C a c b             ' '2 2 '2 2 22 cos cos cos 0 bc A B C a b c              ' '2 2 '2 2 22 cos cos cos 0 b c A B C ab c          ' ' ' 2 2 ' ' 22 cos cos cos 0 cc A B C ab c                   ' ' ' 2 2 22 cos cos cos 0 cb A B C ab c                  ' ' ' 2 2 2 2 22 cos cos cos 0 cb A B C ab c                  ' ' ' 2 2 22 2 2 2 2 1 cos cos cos 0 b c A B C a b c b c                            .
We obtain that:

  ' ' ' 2 2 22 cos cos cos 0 A B C a c b                 , this is true because P  L.

Remark.

We saw that the triangle "s ABC orthocenter H belongs to the locus, from the precedent theorem it results that also O , the center of the circumscribed circle to the triangle ABC (isogonable to H ), belongs to the locus.

Open problem:

What does it represent from the geometry"s point of view the equation of locus L?

In the particular case of an equilateral triangle we can formulate the following:

Proposition:

The locus of the point P from the plane of the equilateral triangle ABC with the property that the pedal triangle of P and the triangle ABC are homological, is the union of the triangle"s heights.

Proof:

Let   ,, P    a point that belongs to locus L. The equation of the locus becomes:

      2 2 2 2 2 2 0                Because:       2 2 2 2 2 2 2 2 2 2 2 2                              2 2 2 2 2 2                                  2                                                              .
We obtain that   or   or   , that shows that P belongs to the medians (heights) of the triangle ABC .

  , respectively AB are concurrent in a point i P (the orthological center of the given triangles), and the lines , ,i i iA A B B C C are concurrent in point (the homological center of the given triangles). To find the triangles i i i


Morgan Meyer

The Rise of the Knowledge Broker

Keywords: knowledge brokering, translation, double peripherality, brokered knowledge

Knowledge brokers are people or organizations that move knowledge around and create connections between researchers and their various audiences. This commentary reviews some of the literature on knowledge brokering and lays out some thoughts on how to analyze and theorize this practice. Discussing the invisibility and interstitiality of knowledge brokers, the author argues that social scientists need to analyze more thoroughly their practices, the brokering devices they use, and the benefits and drawbacks of their double peripherality. The author also argues that knowledge brokers do not only move knowledge, but they also produce a new kind of knowledge: brokered knowledge.

The Rise of the Knowledge Broker

Within our so-called knowledge society, there is nowadays an increasing number of -and need for -knowledge brokers, that is, people whose job it is to move knowledge around and create connections between researchers and their various audiences.(1) However, the ways in which scientific knowledge is transported and translated across the boundaries of different worlds has not been much explored. "We need to understand not only how knowledge is made in specific places but also how transactions occur between places," Shapin (1998, pp. 6-7) argues. In light of Shapin's suggestion, in this commentary I review some of the literature on knowledge brokering and lay out some thoughts on how to analyze and theorize this practice.

So what, exactly, are we to understand by the notion of knowledge broker? Broadly speaking, knowledge brokers can be understood as persons or organizations that facilitate the creation, sharing, and use of knowledge [START_REF] Sverrisson | Translation networks, knowledge brokers and novelty construction: Pragmatic environmentalism in Sweden[END_REF]. Their task is to establish and maintain links between researchers and their audience via the appropriate translation of research findings [START_REF] Lomas | Research and evidence-based decision making[END_REF]. Able to link know-how, know-why, and know-who, the knowledge broker thus works in the public domain as much as in the private domain [START_REF] Blondel | L'émergence des "knowledge brokers" (courtiers de science) et des KIBS: Knowledgeintensive business service[END_REF]. Some argue that knowledge brokering is a fundamental characteristic of postmodern professionals [START_REF] Kakihara | Post-modern" professionals' work and mobile technology. new ways of working in is[END_REF]. Knowledge brokering is on the rise in a variety of areas: the "boundary spanning knowledge broker" is a new role for engineers [START_REF] Johri | Boundary spanning knowledge broker: An emerging role in global engineering firms[END_REF]; academies of science increasingly adopt the role of a broker (see [START_REF] Kissling-Naf | From a learned society to a 21st-century broker: The Swiss Academy of Sciences as a partner in the dialogue with society[END_REF]; among IT professionals there is a proliferation in brokering activities [START_REF] Pawlowski | Supporting shared information systems: Boundary objects, communities, and brokering[END_REF], and even whole countries are said to act as knowledge brokers [START_REF] Oldham | Approaches to knowledge-brokering[END_REF]. Wherever we look, knowledge brokering seems to be growing in importance [START_REF] Bielak | From science communication to knowledge brokering: the shift from "science push" to "policy pull[END_REF].(2) However, can knowledge brokering take place anywhere and everywhere? Knowledge brokering tends to happen in particular locations-in spaces that privilege the brokering of knowledge across boundaries, of which the following are a few examples. Science shops are small entities that carry out scientific research on behalf of citizens and local communities, thus responding to the general public's needs for expertise and knowledge. They act, in particular, as intermediaries between academia and various societal groups (Wachelder, 2003, p. 252). Within some universities a new organizational form-the university technology transfer office-and a new occupation-the professional university technology transfer manager-have emerged over the past couple of decades. They constitute a professional group and space dedicated to brokering work at the margins of the university [START_REF] Vogel | Bureaucrats, brokers, and the entrepreneurial university[END_REF]; see also [START_REF] Jacobson | Organizational factors that influence university-based researchers' engagement in knowledge transfer activities[END_REF].

Let us also mention the increasing importance and influence of science journalists and science writers-especially to allow for shortcuts, much needed because the volume of scientific knowledge has dramatically increased so that even scientists can't be experts in their own vocation anymore (Clemens, 1986, p. 445). (Even the work of interdisciplinary academic journals could be seen as a form of knowledge brokering across disciplines.) It is of interest to further explore brokering spaces like these because they have developed at the intersection of worlds that have become increasingly intertwined and because the traffic of knowledge between these worlds has become increasingly professionalized, formalized, and institutionalized. A key sector, however, is the health care sector where there is a growing and pressing need to bridge the gap between research results and the use of these results for patients. (See especially the practical and theoretical work done by the Canadian Health Services Research Foundation, 2003, which is an often-quoted example.) Let me, therefore, briefly mention 2 examples from the health care domain. For instance, a research project on knowledge brokering at a UK university notes as follows:

The gap between what is known and what is done contributes to poor health outcomes and ultimately results in wasted time and money (...) Different ways of bridging this gap have been proposed, but one of the most popular involves employing individuals to act as "knowledge brokers." Their job is to create linkages and facilitate the transfer of knowledge between researchers and practitioners. (Leeds Institute of Health Sciences, 2009; see also [START_REF] Ward | Knowledge brokering: The missing link in the evidence to action chain? Evidence & Policy: A Journal of Research[END_REF] Another example comes from a group of doctors working in a hospital in France. Having identified the gap between available therapeutic research results and physicians' prescriptions as well as the difficulties to transfer research into practice (be it because of a lack of trust, a lack of time and resources, or the sheer amount of available data), they propose to bridge the gap between knowledge and the use thereof by comprehensively collecting and summarizing clinical trial reports, scoring and ranking these according to their level of evidence, exploring and synthesizing the data using meta-analysis, summarizing these results, representing them in an easily understandable form, and transmitting the overview findings to prescribers at the time they need them. (Boissel, Amsallem, Cucherat, Nony, & Haugh, 2004, p. 609) As we can see from this latter example, brokering involves a range of different practices: the identification and localization of knowledge, the redistribution and dissemination of knowledge, and the rescaling and transformation of this knowledge. Brokering knowledge thus means far more than simply moving knowledge-it also means transforming knowledge.

Having said that, despite these general traits, knowledge brokering is likely to look very different in the various brokering spaces mentioned above, not least because the needs and expectations of the knowledge users might differ substantially (be it local communities in search of specific knowledge, corporations wanting profitability, doctors and patients calling for effective treatments, policy makers needing to make decisions, etc.).

Theorizing Brokering

How are we to theorize the practice of brokering? Wenger (1998, p. 109) has offered a useful definition: "brokering (...) involves processes of translation, coordination, and alignment between perspectives. (...) It also requires the ability to link practices by facilitating transactions between them." Knowledge brokers are said to act in three different manners: as knowledge managers, linkage agents (between producers and users of knowledge), or capacity builders (through enhancing access to knowledge; [START_REF] Oldham | Approaches to knowledge-brokering[END_REF]. In doing so, they are involved in a broad range of activities: articulation work, communication work, identification work, mediation work, educational work, and so on. All these activities require a variety of tools, such as organizing seminars or meetings (see Sverrisson, 2001, p. 317), developing databases, producing plain-language booklets (Kramer & Wells, 2005, p. 431) and so on and so forth. Above all, brokers have to create a common language, being a sort of "linguistic creator": "The task is none other than that of constructing a language in which the parties can place themselves and engage with each other in mutual understanding" (Barnett, 2003, p. xvii, emphasis removed). The typical brokering devices used still need to be identified and characterized in more detail.

A helpful concept to theorize knowledge brokering is the notion of translation. [START_REF] Callon | Some elements of a sociology of translation: domestication of the scallops and the fishermen of Saint Brieuc bay[END_REF] defines translation as a process involving several moments: defining an actor; testing, stabilizing, and specifying the roles of this actor; and, finally, rendering it mobile. In Law's (2002, p. 99) words, "To translate is to connect, to displace, to move, to shift from one place, one modality, one form, to another while retaining something. Only something. Not everything. While therefore losing something. Betraying whatever is not carried over." Brokering can thus be conceived as being a form of translation with a specific emphasis on the following features: a need for at least two simultaneous translations and a reification and increased visibility of the role of "translators," that is, brokers.

Let us also mention Shinn (2002, p. 611) who has coined the term transversality-a practice that "crosses cognitive, economic and societal boundaries." In particular, he identified an informal and unofficial group of people, "research technologists," who operate at the interface between institutions. He writes, "They stand 'in-between' orthodox professions and bodies, and are thereby interstitial. They both sustain instituted differentiations and divisions of labour and violate them" (Shinn, 2002, p. 612).( 3) Certainly, it is common to argue that knowledge brokers are somehow in between worlds [START_REF] Bielak | From science communication to knowledge brokering: the shift from "science push" to "policy pull[END_REF][START_REF] Lomas | The in-between world of knowledge brokering[END_REF][START_REF] Satterfield | The "in-between people": Participation of community health representatives in diabetes prevention and care in American Indian and Alaska native communities[END_REF]. Yet I would argue that a more fruitful way to think about those in between two or more worlds is to think in terms of peripheries. In the community of practice literature, the term periphery of practice is developed (Wenger, 1998, p. 117), and it has been argued that there are "multiple, varied, more-or less-engaged and inclusive ways of being located in the fields of participation" (Lave & Wenger, 1991, pp. 35-36). What, then, about those people who are peripheral to two worlds? What about those people who are not on an inbound trajectory into either one or the other world but who perpetually are on a peripheral trajectory or a boundary trajectory [START_REF] Wenger | Communities of practice: Learning, meaning, and identity[END_REF]? Even more so, some have argued that knowledge brokers might be well placed to resist the "dogmas" of the domains they are eventually meant to bring together (Hargadon, 2002, p. 77). How do knowledge brokers talk about, experience, and gain capital from their "double peripherality," that is, from the fact that they are partially connected to the two worlds they bridge? And what is the cost of being marginal to multiple worlds (see [START_REF] Star | Power, technology and the phenomenology of conventions: On being allergic to onions[END_REF], especially since these marginalities might be viewed with suspicion? These are the sort of questions, I would argue, that need further scrutiny.

Another layer to the question of the knowledge broker's position is the question of visibility/invisibility-an issue that frequently features in the literature. Despite the emergence of spaces that specialize in the translation of knowledge between different worlds, knowledge brokering still tends to be unrecognized and unplanned [START_REF] Johri | Boundary spanning knowledge broker: An emerging role in global engineering firms[END_REF]; see also Wenger, 1998, p. 110). There is a lack of support and training for knowledge brokers [START_REF] Surridge | Science-driven integrated river basin management: A mirage?[END_REF]. It is said to be an activity that is usually not acknowledged nor recognized in institutions [START_REF] Bielak | From science communication to knowledge brokering: the shift from "science push" to "policy pull[END_REF], an activity that tends to be invisible and take place "back stage" (Vogel & Kaghan, 2001, p. 361). Therefore, knowledge brokers often try to make their roles and work visible and appear valuable to others. This might be especially difficult within the value system and the hierarchies of the academic world, a world that rewards and prioritizes disciplinary training, journal papers, research grants (Surridge & Harris, 2007, p. 309), and monopolistic organizational linkages (Joerges & Shinn, 2001, p. 8). As a case in point, here is an extract from an interview about science shops: Science Shops (...) will never be academic departments. How good is the department of Chemistry in "X" University at being a Science Shop? I suspect that it would be terrible. Science Shops have a particular purpose and particular roleacting as a broker between at least two worlds is a remarkably difficult thing to do and I think that if Science Shops are judged strictly by the rules of one world or the other they will always come up short. (Anonymous, 2004, p. 5) It must be noted, though, that invisibility comes with its benefits: Some research technologists opt for (social) invisibility because this is "fully consistent with the tenets of the interstitial stance, and such a measure drastically reduces the risk of jealousy and enmity" and helps to avoid turf battles (Shinn & Joerges, 2002, p. 215).( 4) Perhaps, this invisibility is inevitable: Because the role of knowledge brokers lies in moving and making things flow across boundaries, erecting boundaries (around their own practices) is not an option.

What is more, knowledge brokers produce, enable, and facilitate movement, and they themselves are in movement. They move back and forth between different social worlds. Not only are they transferring knowledge in one direction only, they are engaged in an exchange of knowledge through moving between places.(5) Hence, the word transfer does not do justice to the practices of knowledge brokers. De [START_REF] De Laet | Patents, knowledge, and technology transfer: On the politics of positioning and place[END_REF] prefers to use terms like travel and transformation instead of transfer. Like other forms of mediation, knowledge brokering is indeed collective and interactive (see Osborne, 2004, p. 443). In the case of knowledge brokering, this collective exploration is based on two key movements. On one hand, there is a translation of knowledge from one world to another. On the other hand, we see efforts to make knowledge socially, politically, and/or economically robust. So both the translation of knowledge and the translation of accountability/usability take place. The end result of these translations is the production of a new kind of knowledge-what we could call brokered knowledge. Brokered knowledge is knowledge made more robust, more accountable, more usable; knowledge that "serves locally" at a given time; knowledge that has been de-and reassembled.

All these points raise not only questions about the invisibility, interstitiality, and interactivity of knowledge brokers, but social scientists need to analyze more thoroughly their practices, the devices they create and use, and the benefits and drawbacks from their peripheral status.

Notes

1. The term is also used in other arenas:

In business, a broker is an agent, promoter, dealer, fixer, trader, someone who buys and sells; in politics, a broker is a diplomat, mediator, go-between, negotiator; in the information world, a broker is someone who knows how to access or acquire information and who provides a gateway to information resources; in education, a broker is a proactive facilitator who connects people, networks, organizations and resources and establishes the conditions to create something new or add value to something that already exists. (Jackson, 2003, p. 4) 2. Worthy of being mentioned here is the notion of "translational medicine." Analyzing translational research in biomedicine, [START_REF] Kraft | New light through an old window: What's new about translational research in biomedicine[END_REF] notes that there are new institutional, professional, and disciplinary formations and that certain roles, such as that of the "clinician scientist," are reappearing.

3. Joerges and Shinn (2001, pp. 7-8) further write, These research-technologists admittedly work within universities, industry, state or independent establishments, yet at the same time they maintain some distance from their organization. In many instances, they pursue "hybrid careers." (...) Many research technologists develop a personality make-up suited to sustain many-sided professional relationships and "multi-lingual" cognitive worlds.

For an extended discussion see Shinn and Joerges (2002, pp. 213-216).

4. The issue is perhaps also for knowledge brokers to become distinctive without becoming distinct (see Shinn & Joerges, 2002, p. 214). 5. It is useful here to mention Osborne's (2004, p. 440) definition of a mediator as "the intellectual worker as enabler, fixer, catalyst and broker of ideas. Perhaps the salient feature (...) is the association of mediators with movement. The mediator is simply the one who gets things moving [italics in original]."

Acknowledgments

This paper has benefited from the comments of a number of colleagues. The author would like to thank: Madeleine Akrich, Michel Callon, Liliana Doganova, Antoine Hennion, Brice Laurent, Sabine Maasen, Cécile Meadel, Susan Molyneux-Hodgson, Fabian Muniesa, Neil Pollock, Jörg Potthast, Susanna Priest, Vololona Rabeharisoa, Katharina Schlierf, Kate Woodthorpe.