Charm++: Charm Source Code Documentation

00001 /*
00002   liveViz: image-assembly interface.
00003 
00004 Orion Sky Lawlor, olawlor@acm.org, 6/11/2002
00005 */
00006 #include "liveViz.h"
00007 #include "liveViz_impl.h"
00008 #include "ImageData.h"
00009 
00010 PUPbytes(liveVizConfig)
00011 
00012 liveVizConfig lv_config;
00013 CkReduction::reducerType image_combine_reducer;
00014 CProxy_liveVizGroup lvG;
00015 CkCallback clientGetImageCallback;
00016 
00017 //Called by clients to start liveViz.
00018 void liveVizInit(const liveVizConfig &cfg, CkArrayID a, CkCallback c)
00019 {
00020   if (CkMyPe()!=0) CkAbort("liveVizInit must be called only on processor 0!");
00021   clientGetImageCallback=c;
00022   //Broadcast the liveVizConfig object via our group:
00023   //  lv_config can't be a readonly because we may be called after
00024   //  main::main (because, e.g., communication is needed to find the
00025   //  bounding box inside cfg).
00026   lvG = CProxy_liveVizGroup::ckNew(cfg);
00027 }
00028 
00029 
00030 //Called by reduction handler once every processor has the lv_config object
00031 void liveVizInitComplete(void *rednMessage) {
00032   delete (CkReductionMsg *)rednMessage;
00033   liveViz0Init(lv_config);
00034 }
00035 
00036 liveVizRequestMsg *liveVizRequestMsg::buildNew(const liveVizRequest &req,const void *data,int dataLen)
00037 {
00038         liveVizRequestMsg *m=new (dataLen,0) liveVizRequestMsg();
00039         m->req=req;
00040         memcpy(m->data,data,dataLen);
00041         m->dataLen=dataLen;
00042         return m;
00043 }
00044 
00045 
00046 //Called by lower layers when an image request comes in on processor 0.
00047 //  Just forwards request on to user.
00048 void liveViz0Get(const liveVizRequest &req,void *data,int dataLen)
00049 {
00050   clientGetImageCallback.send(liveVizRequestMsg::buildNew(req,data,dataLen));
00051 }
00052 
00053 /*This array has 512 entries-- it's used to clip off large values
00054 when summing bytes (like image values) together.  On a machine with
00055 a small cache, it may be better to use an "if" instead of this table.
00056 */
00057 static byte *overflowArray=CkImage::newClip();
00058 
00059 #if 1
00060 /****************** Fast but complex image combining *****************
00061 
00062 Here I create a list of non-overlapping images (lines) and contribute 
00063 the list of images rather than the combined images.
00064 
00065 The contributed data looks like:
00066   a list of Images (lines) packed into a run of bytes
00067 **********************************************************************/
00068 
00071 void liveVizDeposit(const liveVizRequest &req,
00072                     int startx, int starty,
00073                     int sizex, int sizey, const byte * src,
00074                     ArrayElement* client,
00075                     liveVizCombine_t combine)
00076 {
00077   if (lv_config.getVerbose(2))
00078     CkPrintf("liveVizDeposit> Deposited image at (%d,%d), (%d x %d) pixels, on pe %d \n",startx,starty,sizex,sizey,CkMyPe());
00079 
00080   ImageData imageData (lv_config.getBytesPerPixel ());
00081   CkReductionMsg* msg = CkReductionMsg::buildNew(imageData.GetBuffSize (startx,
00082                                                                         starty,
00083                                                                         sizex,
00084                                                                         sizey,
00085                                                                         req.wid,
00086                                                                                                                                                 req.ht,
00087                                                                         src),
00088                                                  NULL, image_combine_reducer);
00089   imageData.WriteHeader(combine,&req,(byte*)(msg->getData()));
00090   imageData.AddImage (req.wid, (byte*)(msg->getData()));
00091 
00092   //Contribute this image to the reduction
00093   msg->setCallback(CkCallback(vizReductionHandler));
00094   
00095   client->contribute(msg);
00096 }
00097 
00098 
00104 CkReductionMsg *imageCombineReducer(int nMsg,CkReductionMsg **msgs)
00105 {
00106   if (nMsg==1) { //Don't bother copying if there's only one source
00107     if (lv_config.getVerbose(2))
00108       CkPrintf("imageCombine> Skipping combine on pe %d\n",CkMyPe());
00109     
00110     CkReductionMsg *ret=msgs[0];
00111     msgs[0]=NULL; //Prevent reduction manager from double-delete
00112     return ret;
00113   }
00114 
00115   if (lv_config.getVerbose(2))
00116     CkPrintf("imageCombine> image combine on pe %d\n",CkMyPe());
00117 
00118   ImageData imageData (lv_config.getBytesPerPixel ());
00119 
00120   CkReductionMsg* msg = CkReductionMsg::buildNew(imageData.CombineImageDataSize (nMsg,
00121                                                                                  msgs),
00122                                                  NULL, image_combine_reducer);
00123 
00124   imageData.CombineImageData (nMsg, msgs, (byte*)(msg->getData()));
00125   return msg;
00126 }
00127 
00128 /* Called once at end of reduction:
00129    Unpacks images, combines them to form one image and passes it on to layer 0. */
00130 void vizReductionHandler(void *r_msg)
00131 {
00132   CkReductionMsg *msg = (CkReductionMsg*)r_msg;
00133   ImageData imageData (lv_config.getBytesPerPixel ());
00134   liveVizRequest req;
00135   byte *image = imageData.ConstructImage ((byte*)(msg->getData ()), req);
00136   
00137   if (lv_config.getVerbose(2))
00138       CkPrintf("vizReductionHandler> Assembled image on PE %d \n", CkMyPe());
00139   
00140   if (lv_config.getBytesPerPixel()!=lv_config.getNetworkBytesPerPixel())
00141   { /* Reformat image for the wire: 
00142       (only used by floating-point images for now) */
00143         int row=req.wid*lv_config.getBytesPerPixel();
00144         int netRow=req.wid*lv_config.getNetworkBytesPerPixel();
00145         byte *netImage=new byte[req.ht*netRow];
00146         liveVizFloatToRGB(req, (float *)image, netImage, req.wid*req.ht);
00147         delete[] image;
00148         image=netImage;
00149   }
00150 
00151   liveViz0Deposit(req,image);
00152 
00153   delete[] image;
00154   delete msg;
00155 }
00156 
00157 static void liveVizNodeInit(void) {
00158   image_combine_reducer=CkReduction::addReducer(imageCombineReducer);
00159 }
00160 
00161 #else
00162 
00163 /****************** Fairly Slow, but straightforward image combining *****************
00164 The contributed data looks like:
00165         liveVizRequest
00166         Rectangle of image, in final image coordinates (fully clipped)
00167         image data
00168 
00169 This turned out to be incredibly hideous, because the simple data
00170 structure above has to be compressed into a flat run of bytes.
00171 I'm considering changing the reduction interface to use messages,
00172 or some sort of pup'd object.
00173 */
00174 
00175 
00176 CkReductionMsg *allocateImageMsg(const liveVizRequest &req,const CkRect &r,
00177         byte **imgDest)
00178 {
00179   imageHeader hdr(req,r);
00180   CkReductionMsg *msg=CkReductionMsg::buildNew(
00181         sizeof(imageHeader)+r.area()*lv_config.getBytesPerPixel(),
00182         NULL,imageCombineReducer);
00183   byte *dest=(byte *)msg->getData();
00184   *(imageHeader *)dest=hdr;
00185   *imgDest=dest+sizeof(hdr);
00186   return msg;
00187 }
00188 
00189 //Called by clients to deposit a piece of the final image
00190 void liveVizDeposit(const liveVizRequest &req,
00191                     int startx, int starty,
00192                     int sizex, int sizey, const byte * src,
00193                     ArrayElement* client)
00194 {
00195   if (lv_config.getVerbose(2))
00196     CkPrintf("liveVizDeposit> Deposited image at (%d,%d), (%d x %d) pixels, on pe %d\n",
00197         startx,starty,sizex,sizey,CkMyPe());
00198 
00199 //Allocate a reductionMessage:
00200   CkRect r(startx,starty, startx+sizex,starty+sizey);
00201   r=r.getIntersect(CkRect(req.wid,req.ht)); //Never copy out-of-bounds regions
00202   if (r.isEmpty()) r.zero();
00203   int bpp=lv_config.getBytesPerPixel();
00204   byte *dest;
00205   CkReductionMsg *msg=allocateImageMsg(req,r,&dest);
00206 
00207 //Copy our image into the reductionMessage:
00208   if (!r.isEmpty()) {
00209     //We can't just copy image with memcpy, because we may be clipping user data here:
00210     CkImage srcImage(sizex,sizey,bpp,(byte *)src);
00211     srcImage.window(r.getShift(-startx,-starty)); //Portion of src overlapping dest
00212     CkImage destImage(r.wid(),r.ht(),bpp,dest);
00213     destImage.put(0,0,srcImage);
00214   }
00215 
00216 //Contribute this image to the reduction
00217   msg->setCallback(CkCallback(vizReductionHandler));
00218   client->contribute(msg);
00219 }
00220 
00221 /*Called by the reduction manager to combine all the source images
00222 received on one processor.
00223 */
00224 CkReductionMsg *imageCombine(int nMsg,CkReductionMsg **msgs)
00225 {
00226   if (nMsg==1) { //Don't bother copying if there's only one source
00227         if (lv_config.getVerbose(2))
00228             CkPrintf("imageCombine> Skipping combine on pe %d\n",CkMyPe());
00229         CkReductionMsg *ret=msgs[0];
00230         msgs[0]=NULL; //Prevent reduction manager from double-delete
00231         return ret;
00232   }
00233   int m;
00234   int bpp=lv_config.getBytesPerPixel();
00235   imageHeader *firstHdr=(imageHeader *)msgs[0]->getData();
00236 
00237 //Determine the size of the output image
00238   CkRect destRect; destRect.makeEmpty();
00239   for (m=0;m<nMsg;m++) destRect=destRect.getUnion(((imageHeader *)msgs[m]->getData())->r);
00240 
00241 //Allocate output message of that size
00242   byte *dest;
00243   CkReductionMsg *msg=allocateImageMsg(firstHdr->req,destRect,&dest);
00244 
00245 //Add each source image to the destination
00246 // Everything should be pre-clippped, so no further geometric clipping is needed.
00247 // Brightness clipping, of course, is still necessary.
00248   CkImage destImage(destRect.wid(),destRect.ht(),bpp,dest);
00249   destImage.clear();
00250   for (m=0;m<nMsg;m++) {
00251         byte *src=(byte *)msgs[m]->getData();
00252         imageHeader *mHdr=(imageHeader *)src;
00253         src+=sizeof(imageHeader);
00254         if (lv_config.getVerbose(2))
00255             CkPrintf("imageCombine>    pe %d  image %d is (%d,%d, %d,%d)\n",
00256                   CkMyPe(),m,mHdr->r.l,mHdr->r.t,mHdr->r.r,mHdr->r.b);
00257         CkImage srcImage(mHdr->r.wid(),mHdr->r.ht(),bpp,src);
00258         destImage.addClip(mHdr->r.l-destRect.l,mHdr->r.t-destRect.t,srcImage,overflowArray);
00259   }
00260 
00261   return msg;
00262 }
00263 
00264 /*
00265 Called once final image has been assembled (reduction handler).
00266 Unpacks image, and passes it on to layer 0.
00267 */
00268 void vizReductionHandler(void *r_msg)
00269 {
00270   CkReductionMsg *msg = (CkReductionMsg*)r_msg;
00271   imageHeader *hdr=(imageHeader *)msg->getData();
00272   byte *srcData=sizeof(imageHeader)+(byte *)msg->getData();
00273   int bpp=lv_config.getBytesPerPixel();
00274   CkRect destRect(0,0,hdr->req.wid,hdr->req.ht);
00275   if (destRect==hdr->r) { //Client contributed entire image-- pass along unmodified
00276     liveViz0Deposit(hdr->req,srcData);
00277   }
00278   else
00279   { //Client didn't quite cover whole image-- have to pad
00280     CkImage src(hdr->r.wid(),hdr->r.ht(),bpp,srcData);
00281     CkAllocImage dest(hdr->req.wid,hdr->req.ht,bpp);
00282     dest.clear();
00283     dest.put(hdr->r.l,hdr->r.t,src);
00284     liveViz0Deposit(hdr->req,dest.getData());
00285   }
00286   delete msg;
00287 }
00288 #endif
00289 
00290 
00291 #include "liveViz.def.h"
libs/ck-libs/liveViz/liveViz.C
